/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (https://www.swig.org).
 * Version 4.2.1
 *
 * Do not make changes to this file unless you know what you are doing - modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */

  #include "nan.h"

  #include "config.h"
  #include "libxml/xmlversion.h"
  #include "buf.h"
  #include "catalog.h"
  #include "chvalid.h"
  #include "dict.h"
  #include "encoding.h"
  #include "entities.h"
  #include "globals.h"
  #include "hash.h"
  #include "HTMLparser.h"
  #include "HTMLtree.h"
  #include "list.h"
  #include "parser.h"
  #include "parserInternals.h"
  #include "pattern.h"
  #include "relaxng.h"
  #include "SAX2.h"
  #include "SAX.h"
  #include "tree.h"
  #include "threads.h"
  #include "uri.h"
  #include "valid.h"
  #include "xinclude.h"
  #include "xlink.h"
  #include "xmlIO.h"
  #include "xmlmemory.h"
  #include "xmlmodule.h"
  #include "xmlreader.h"
  #include "xmlregexp.h"
  #include "xmlsave.h"
  #include "xmlschemas.h"
  #include "xmlschemastypes.h"
  #include "xmlstring.h"
  #include "xmlunicode.h"
  #include "xmlwriter.h"
  #include "xpath.h"
  #include "xpathInternals.h"
  #include "xpointer.h"
  
  #include "xml_sax_parser.h"



#define SWIG_VERSION 0x040201
#define SWIGJAVASCRIPT
/* -----------------------------------------------------------------------------
 *  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 defined(__GNUC__)
#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#    ifndef GCC_HASCLASSVISIBILITY
#      define GCC_HASCLASSVISIBILITY
#    endif
#  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

/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif

/* Intel's compiler complains if a variable which was never initialised is
 * cast to void, which is a common idiom which we use to indicate that we
 * are aware a variable isn't used.  So we just silence that warning.
 * See: https://github.com/swig/swig/issues/192 for more discussion.
 */
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif

#if defined(__cplusplus) && __cplusplus >=201103L
# define SWIG_NULLPTR nullptr
#else
# define SWIG_NULLPTR NULL
#endif 

/* -----------------------------------------------------------------------------
 * swigcompat.swg
 *
 * Macros to provide support compatibility with older C and C++ standards.
 * ----------------------------------------------------------------------------- */

/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
 * if you're missing it.
 */
#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
     (defined __cplusplus && __cplusplus >= 201103L) || \
     defined SWIG_HAVE_SNPRINTF) && \
    !defined SWIG_NO_SNPRINTF
# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
#else
/* Fallback versions ignore the buffer size, but most of our uses either have a
 * fixed maximum possible size or dynamically allocate a buffer that's large
 * enough.
 */
# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
#endif



#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 

#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0) 



#include <node.h>
//Older version of node.h does not include this
#include <node_version.h>


#include <v8.h>

#undef SWIG_V8_VERSION
#define SWIG_V8_VERSION ((V8_MAJOR_VERSION / 10) * 4096 + \
                         (V8_MAJOR_VERSION % 10) * 256 + \
                         (V8_MINOR_VERSION / 10) * 16 + \
                         (V8_MINOR_VERSION % 10))

#include <errno.h>
#include <limits.h>
#include <stdlib.h>
#include <assert.h>

/* -----------------------------------------------------------------------------
 * 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
#define SWIG_POINTER_NO_NULL       0x4
#define SWIG_POINTER_CLEAR         0x8
#define SWIG_POINTER_RELEASE       (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)

/* 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 returning 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)
/* Runtime errors are < 0 */
#define SWIG_ERROR                 (-1)
/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
/* Errors < -200 are generic runtime specific errors */
#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)

#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 temporary 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 object 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(r) (r)
#  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 equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
  int equiv = 1;
  const char* te = tb + strlen(tb);
  const char* ne = nb;
  while (equiv != 0 && *ne) {
    for (nb = ne; *ne; ++ne) {
      if (*ne == '|') break;
    }
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
    if (*ne) ++ne;
  }
  return equiv;
}

/*
  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) {
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}

/*
  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(const 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.  Choose the last
     name. It should be the most specific; a fully resolved name
     but not necessarily with default template parameters expanded. */
  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) {
      size_t l = 0;
      size_t r = iter->size - 1;
      do {
	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
	size_t i = (l + r) >> 1;
	const char *iname = iter->types[i]->name;
	if (iname) {
	  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 {
      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";
  const unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu =  u + sz;
  for (; u != eu; ++u) {
    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) {
  unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu = u + sz;
  for (; u != eu; ++u) {
    char d = *(c++);
    unsigned char uu;
    if ((d >= '0') && (d <= '9'))
      uu = (unsigned char)((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = (unsigned char)((d - ('a'-10)) << 4);
    else
      return (char *) 0;
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (unsigned char)(d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (unsigned char)(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

/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#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


/* ---------------------------------------------------------------------------
 * These typedefs and defines are used to deal with v8 API changes
 *
 * Useful table of versions: https://nodejs.org/en/download/releases/
 * ---------------------------------------------------------------------------*/

#if (SWIG_V8_VERSION < 0x0704)
#define SWIGV8_STRING_NEW2(cstr, len) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), cstr, v8::String::kNormalString, len)
#else
#define SWIGV8_STRING_NEW2(cstr, len) (v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), cstr, v8::NewStringType::kNormal, len)).ToLocalChecked()
#endif

typedef void SwigV8ReturnValue;
typedef v8::FunctionCallbackInfo<v8::Value> SwigV8Arguments;
typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
#define SWIGV8_RETURN(val) args.GetReturnValue().Set(val); return
#define SWIGV8_RETURN_INFO(val, info) info.GetReturnValue().Set(val); return

#define SWIGV8_HANDLESCOPE() v8::HandleScope scope(v8::Isolate::GetCurrent());
#define SWIGV8_HANDLESCOPE_ESC() v8::EscapableHandleScope scope(v8::Isolate::GetCurrent());
#define SWIGV8_ESCAPE(val) return scope.Escape(val)

#define SWIGV8_ADJUST_MEMORY(size) v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(size)
#define SWIGV8_CURRENT_CONTEXT() v8::Isolate::GetCurrent()->GetCurrentContext()
#define SWIGV8_THROW_EXCEPTION(err) v8::Isolate::GetCurrent()->ThrowException(err)

#if (SWIG_V8_VERSION < 0x0704)
#define SWIGV8_STRING_NEW(str) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), str, v8::String::kNormalString)
#define SWIGV8_SYMBOL_NEW(sym) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sym, v8::String::kNormalString)
#else
#define SWIGV8_STRING_NEW(str) (v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), str, v8::NewStringType::kNormal)).ToLocalChecked()
#define SWIGV8_SYMBOL_NEW(sym) (v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sym, v8::NewStringType::kNormal)).ToLocalChecked()
#endif

#if (SWIG_V8_VERSION < 0x0704)
#define SWIGV8_MAYBE_CHECK(maybe) maybe.FromJust()
#else
#define SWIGV8_MAYBE_CHECK(maybe) maybe.Check()
#endif

#define SWIGV8_ARRAY_NEW(size) v8::Array::New(v8::Isolate::GetCurrent(), size)
#define SWIGV8_BOOLEAN_NEW(bool) v8::Boolean::New(v8::Isolate::GetCurrent(), bool)
#define SWIGV8_EXTERNAL_NEW(val) v8::External::New(v8::Isolate::GetCurrent(), val)
#define SWIGV8_FUNCTEMPLATE_NEW(func) v8::FunctionTemplate::New(v8::Isolate::GetCurrent(), func)
#define SWIGV8_FUNCTEMPLATE_NEW_VOID() v8::FunctionTemplate::New(v8::Isolate::GetCurrent())
#define SWIGV8_INT32_NEW(num) v8::Int32::New(v8::Isolate::GetCurrent(), num)
#define SWIGV8_INTEGER_NEW(num) v8::Integer::New(v8::Isolate::GetCurrent(), num)
#define SWIGV8_INTEGER_NEW_UNS(num) v8::Integer::NewFromUnsigned(v8::Isolate::GetCurrent(), num)
#define SWIGV8_NUMBER_NEW(num) v8::Number::New(v8::Isolate::GetCurrent(), num)
#define SWIGV8_OBJECT_NEW() v8::Object::New(v8::Isolate::GetCurrent())
#define SWIGV8_UNDEFINED() v8::Undefined(v8::Isolate::GetCurrent())
#define SWIGV8_ARRAY v8::Local<v8::Array>
#define SWIGV8_FUNCTION_TEMPLATE v8::Local<v8::FunctionTemplate>
#define SWIGV8_OBJECT v8::Local<v8::Object>
#define SWIGV8_OBJECT_TEMPLATE v8::Local<v8::ObjectTemplate>
#define SWIGV8_OBJECT_TEMPLATE_NEW() v8::ObjectTemplate::New(v8::Isolate::GetCurrent())
#define SWIGV8_VALUE v8::Local<v8::Value>
#define SWIGV8_NULL() v8::Null(v8::Isolate::GetCurrent())
#define SWIGV8_ARRAY_GET(array, index) (array)->Get(SWIGV8_CURRENT_CONTEXT(), index).ToLocalChecked()
#define SWIGV8_ARRAY_SET(array, index, value) SWIGV8_MAYBE_CHECK((array)->Set(SWIGV8_CURRENT_CONTEXT(), index, value))

#define SWIGV8_SET_CLASS_TEMPL(class_templ, class) class_templ.Reset(v8::Isolate::GetCurrent(), class);

#if SWIG_V8_VERSION < 0x0608
#define SWIGV8_TO_OBJECT(handle) (handle)->ToObject()
#define SWIGV8_TO_STRING(handle) (handle)->ToString()
#define SWIGV8_NUMBER_VALUE(handle) (handle)->NumberValue()
#define SWIGV8_INTEGER_VALUE(handle) (handle)->IntegerValue()
#define SWIGV8_BOOLEAN_VALUE(handle) (handle)->BooleanValue()
#define SWIGV8_WRITE_UTF8(handle, buffer, len) (handle)->WriteUtf8(buffer, len)
#define SWIGV8_UTF8_LENGTH(handle) (handle)->Utf8Length()
#define SWIGV8_OBJECT_TEMPLATE_INSTACE(tmpl) tmpl->NewInstance();
#else
#define SWIGV8_TO_OBJECT(handle) (handle)->ToObject(SWIGV8_CURRENT_CONTEXT()).ToLocalChecked()
#define SWIGV8_TO_STRING(handle) (handle)->ToString(SWIGV8_CURRENT_CONTEXT()).ToLocalChecked()
#define SWIGV8_NUMBER_VALUE(handle) (handle)->NumberValue(SWIGV8_CURRENT_CONTEXT()).ToChecked()
#define SWIGV8_INTEGER_VALUE(handle) (handle)->IntegerValue(SWIGV8_CURRENT_CONTEXT()).ToChecked()
#define SWIGV8_WRITE_UTF8(handle, buffer, len) (handle)->WriteUtf8(v8::Isolate::GetCurrent(), buffer, len)
#define SWIGV8_UTF8_LENGTH(handle) (handle)->Utf8Length(v8::Isolate::GetCurrent())
#define SWIGV8_OBJECT_TEMPLATE_INSTACE(tmpl) tmpl->NewInstance(SWIGV8_CURRENT_CONTEXT()).ToLocalChecked();
#if (SWIG_V8_VERSION < 0x0704)
#define SWIGV8_BOOLEAN_VALUE(handle) (handle)->BooleanValue(SWIGV8_CURRENT_CONTEXT()).ToChecked()
#else
#define SWIGV8_BOOLEAN_VALUE(handle) (handle)->BooleanValue(v8::Isolate::GetCurrent())
#endif
#endif

/* ---------------------------------------------------------------------------
 * Error handling
 *
 * ---------------------------------------------------------------------------*/

#define SWIG_Error(code, msg)     SWIGV8_ErrorHandler.error(code, msg)
#define SWIG_exception(code, msg) do { SWIGV8_ErrorHandler.error(code, msg); SWIG_fail; } while (0)
#define SWIG_fail                 goto fail
#define SWIGV8_OVERLOAD false

SWIGINTERN void SWIG_V8_Raise(const char *msg) {
  SWIGV8_THROW_EXCEPTION(v8::Exception::Error(SWIGV8_STRING_NEW(msg)));
}

SWIGINTERN void SWIG_V8_Raise(SWIGV8_VALUE obj, const char *msg) {
  SWIGV8_THROW_EXCEPTION(v8::Exception::Error(SWIGV8_TO_STRING(obj)));
}


/*
  Note: There are two contexts for handling errors.
  A static V8ErrorHandler is used in not overloaded methods.
  For overloaded methods the throwing type checking mechanism is used
  during dispatching. As V8 exceptions can not be reset properly
  the trick is to use a dynamic ErrorHandler with same local name as the global
  one.

  - See definition of SWIG_Error above.
  - See code templates 'JS_function_dispatcher', 'JS_functionwrapper_overload',
    and 'JS_function_dispatch_case' in javascriptcode.swg

*/
class V8ErrorHandler {
public:
  virtual ~V8ErrorHandler() {}
  virtual void error(int code, const char *msg) {
    SWIG_V8_Raise(msg);
  }
};
// this is used in usually
SWIGRUNTIME V8ErrorHandler SWIGV8_ErrorHandler;

// instances of this are used in overloaded functions
class OverloadErrorHandler: public V8ErrorHandler {
public:
  virtual void error(int code, const char *msg) {
    err = v8::Exception::Error(SWIGV8_STRING_NEW(msg));
    if(code != SWIG_TypeError) {
        SWIGV8_THROW_EXCEPTION(err);
    }
  }
  SWIGV8_VALUE err;
};

/* ---------------------------------------------------------------------------
 * Basic Proxy object
 *
 * ---------------------------------------------------------------------------*/

// Note: to trigger the v8 gc more often one can tell v8 about the memory consumption
// TODO: we could add a v8 specific parameter to control this value
#define SWIGV8_AVG_OBJ_SIZE 1000

class SWIGV8_Proxy {
public:
  SWIGV8_Proxy(): swigCMemOwn(false), swigCObject(0), info(0), refCount(0), ancestor(NULL), doc(NULL) {
    SWIGV8_ADJUST_MEMORY(SWIGV8_AVG_OBJ_SIZE);
  };

  ~SWIGV8_Proxy() {
    handle.ClearWeak();
    handle.Reset();

    SWIGV8_ADJUST_MEMORY(-SWIGV8_AVG_OBJ_SIZE);
  }

  bool swigCMemOwn;
  void *swigCObject;
  swig_type_info *info;
  v8::Persistent<v8::Object> handle; int refCount; xmlNode* ancestor; xmlDoc* doc;
            
            void Ref();
            void Unref();
};

class SWIGV8_ClientData {
public:
  v8::Persistent<v8::FunctionTemplate> class_templ;

  void (*dtor) (const v8::WeakCallbackInfo<SWIGV8_Proxy> &data);
};

SWIGRUNTIME v8::Persistent<v8::FunctionTemplate> SWIGV8_SWIGTYPE_Proxy_class_templ;

SWIGRUNTIME int SWIG_V8_ConvertInstancePtr(SWIGV8_OBJECT objRef, void **ptr, swig_type_info *info, int flags) {
  SWIGV8_HANDLESCOPE();

  if(objRef->InternalFieldCount() < 1) return SWIG_ERROR;

  SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(objRef->GetAlignedPointerFromInternalField(0));

  if(cdata == NULL) {
    return SWIG_ERROR;
  }
  if(info && cdata->info != info) {
    swig_cast_info *tc = SWIG_TypeCheckStruct(cdata->info, info);
    if (!tc && cdata->info->name) {
      tc = SWIG_TypeCheck(cdata->info->name, info);
    }
    bool type_valid = tc != 0;
    if(!type_valid) {
      return SWIG_TypeError;
    }
    int newmemory = 0;
    *ptr = SWIG_TypeCast(tc, cdata->swigCObject, &newmemory);
    assert(!newmemory); /* newmemory handling not yet implemented */
  } else {
    *ptr = cdata->swigCObject;
  }

  if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !cdata->swigCMemOwn) {
    return SWIG_ERROR_RELEASE_NOT_OWNED;
  } else {
    if (flags & SWIG_POINTER_DISOWN) {
      cdata->swigCMemOwn = false;
    }
    if (flags & SWIG_POINTER_CLEAR) {
      cdata->swigCObject = 0;
    }
  }
  return SWIG_OK;
}


SWIGRUNTIME void SWIGV8_Proxy_DefaultDtor(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  delete proxy;
}

SWIGRUNTIME int SWIG_V8_GetInstancePtr(SWIGV8_VALUE valRef, void **ptr) {
  if(!valRef->IsObject()) {
    return SWIG_TypeError;
  }
  SWIGV8_OBJECT objRef = SWIGV8_OBJECT::Cast(valRef);

  if(objRef->InternalFieldCount() < 1) return SWIG_ERROR;

  SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(objRef->GetAlignedPointerFromInternalField(0));

  if(cdata == NULL) {
    return SWIG_ERROR;
  }

  *ptr = cdata->swigCObject;

  return SWIG_OK;
}

SWIGRUNTIME void SWIGV8_SetPrivateData(SWIGV8_OBJECT obj, void *ptr, swig_type_info *info, int flags) {
  SWIGV8_Proxy *cdata = new SWIGV8_Proxy();
  cdata->swigCObject = ptr;
  cdata->swigCMemOwn = (flags & SWIG_POINTER_OWN) ? 1 : 0;
  cdata->info = info;

  obj->SetAlignedPointerInInternalField(0, cdata);

  cdata->handle.Reset(v8::Isolate::GetCurrent(), obj);

  if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
    cdata->handle.SetWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor, v8::WeakCallbackType::kParameter);
  } else {
    cdata->handle.SetWeak(cdata, SWIGV8_Proxy_DefaultDtor, v8::WeakCallbackType::kParameter);
  }

#if (SWIG_V8_VERSION < 0x0704)
  cdata->handle.MarkIndependent();
// Looks like future versions do not require that anymore:
// https://monorail-prod.appspot.com/p/chromium/issues/detail?id=923361#c11
#endif
}

SWIGRUNTIME int SWIG_V8_ConvertPtr(SWIGV8_VALUE valRef, void **ptr, swig_type_info *info, int flags) {
  SWIGV8_HANDLESCOPE();
  
  /* special case: JavaScript null => C NULL pointer */
  if(valRef->IsNull()) {
    *ptr=0;
    return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
  }
  if(!valRef->IsObject()) {
    return SWIG_TypeError;
  }
  SWIGV8_OBJECT objRef = SWIGV8_OBJECT::Cast(valRef);
  return SWIG_V8_ConvertInstancePtr(objRef, ptr, info, flags);
}

SWIGRUNTIME SWIGV8_VALUE SWIG_V8_NewPointerObj(void *ptr, swig_type_info *info, int flags) {
  SWIGV8_HANDLESCOPE_ESC();
  
  SWIGV8_FUNCTION_TEMPLATE class_templ;

  if (ptr == NULL) {
    v8::Local<v8::Primitive> result = SWIGV8_NULL();
    SWIGV8_ESCAPE(result);
  }

  v8::Isolate *isolate = v8::Isolate::GetCurrent();

  if(info->clientdata != 0) {
    class_templ = v8::Local<v8::FunctionTemplate>::New(isolate, ((SWIGV8_ClientData*) info->clientdata)->class_templ);
  } else {
    class_templ = v8::Local<v8::FunctionTemplate>::New(isolate, SWIGV8_SWIGTYPE_Proxy_class_templ);
  }

  v8::Local<v8::Object> result = class_templ->InstanceTemplate()->NewInstance(SWIGV8_CURRENT_CONTEXT()).ToLocalChecked();

  SWIGV8_SetPrivateData(result, ptr, info, flags);

  SWIGV8_ESCAPE(result);
}

#define SWIG_ConvertPtr(obj, ptr, info, flags)    SWIG_V8_ConvertPtr(obj, ptr, info, flags)
#define SWIG_NewPointerObj(ptr, info, flags)      SWIG_V8_NewPointerObj(ptr, info, flags)

#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_V8_ConvertInstancePtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(thisvalue, type, flags)     SWIG_V8_NewPointerObj(thisvalue, type, flags)

#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_V8_ConvertPtr(obj, pptr, type, 0)
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_V8_NewPointerObj(ptr, type, 0)

#define SWIG_GetInstancePtr(obj, ptr)    SWIG_V8_GetInstancePtr(obj, ptr)

SWIGRUNTIME SwigV8ReturnValue _SWIGV8_wrap_equals(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  void *arg2 = (void *) 0 ;
  bool result;
  int res1;
  int res2;

  if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for equals.");

  res1 = SWIG_GetInstancePtr(args.Holder(), &arg1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ERROR, "Could not get pointer from 'this' object for equals.");
  }
  res2 = SWIG_GetInstancePtr(args[0], &arg2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "equals" "', argument " "1"" of type '" "void *""'");
  }

  result = (bool)(arg1 == arg2);
  jsresult =  SWIGV8_BOOLEAN_NEW(result);

  SWIGV8_RETURN(jsresult);
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}

SWIGRUNTIME SwigV8ReturnValue _wrap_getCPtr(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  long result;
  int res1;

  res1 = SWIG_GetInstancePtr(args.Holder(), &arg1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getCPtr" "', argument " "1"" of type '" "void *""'");
  }

  result = (long)arg1;
  jsresult = SWIGV8_NUMBER_NEW(result);

  SWIGV8_RETURN(jsresult);
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}

/* ---------------------------------------------------------------------------
 * PackedData object
 *
 * ---------------------------------------------------------------------------*/

class SwigV8PackedData {
public:
  SwigV8PackedData(void *data, size_t size, swig_type_info *type): data(nullptr), size(size), type(type) {
    this->data = malloc(size);
    if (this->data != nullptr)
      memcpy(this->data, data, size);
  };

  ~SwigV8PackedData() {
    free(this->data);
  };

  void *data;
  size_t size;
  swig_type_info *type;

  v8::Persistent<v8::Object> handle;
};

SWIGRUNTIMEINLINE
int SwigV8Packed_Check(SWIGV8_VALUE valRef) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT objRef = SWIGV8_TO_OBJECT(valRef);
  if(objRef->InternalFieldCount() < 1) return false;
  v8::Local<v8::Private> privateKey = v8::Private::ForApi(v8::Isolate::GetCurrent(), SWIGV8_STRING_NEW("__swig__packed_data__"));
  v8::Local<v8::Value> flag;
  if (!objRef->GetPrivate(SWIGV8_CURRENT_CONTEXT(), privateKey).ToLocal(&flag))
    return false;
  return (flag->IsBoolean() && SWIGV8_BOOLEAN_VALUE(flag));
}

SWIGRUNTIME
swig_type_info *SwigV8Packed_UnpackData(SWIGV8_VALUE valRef, void *ptr, size_t size) {
  if (SwigV8Packed_Check(valRef)) {
    SWIGV8_HANDLESCOPE();
    
    SwigV8PackedData *sobj;

    SWIGV8_OBJECT objRef = SWIGV8_TO_OBJECT(valRef);

    sobj = static_cast<SwigV8PackedData*>(objRef->GetAlignedPointerFromInternalField(0));
    if (sobj == NULL || sobj->size != size) return 0;
    memcpy(ptr, sobj->data, size);
    return sobj->type;
  } else {
    return 0;
  }
}

SWIGRUNTIME
int SWIGV8_ConvertPacked(SWIGV8_VALUE valRef, void *ptr, size_t sz, swig_type_info *ty) {
  swig_type_info *to = SwigV8Packed_UnpackData(valRef, ptr, sz);
  if (!to) return SWIG_ERROR;
  if (ty) {
    if (to != ty) {
      /* check type cast? */
      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
      if (!tc) return SWIG_ERROR;
    }
  }
  return SWIG_OK;
}

SWIGRUNTIME void _wrap_SwigV8PackedData_delete(const v8::WeakCallbackInfo<SwigV8PackedData> &data) {
  SwigV8PackedData *cdata = data.GetParameter();
  cdata->handle.Reset();
  delete cdata;
}

SWIGRUNTIME
SWIGV8_VALUE SWIGV8_NewPackedObj(void *data, size_t size, swig_type_info *type) {
  SWIGV8_HANDLESCOPE_ESC();

  SwigV8PackedData *cdata = new SwigV8PackedData(data, size, type);
  SWIGV8_OBJECT_TEMPLATE tmpl = SWIGV8_OBJECT_TEMPLATE_NEW();
  tmpl->SetInternalFieldCount(1);
  v8::Local<v8::Object> obj = SWIGV8_OBJECT_TEMPLATE_INSTACE(tmpl);

  v8::Local<v8::Private> privateKey = v8::Private::ForApi(v8::Isolate::GetCurrent(), SWIGV8_STRING_NEW("__swig__packed_data__"));
  obj->SetPrivate(SWIGV8_CURRENT_CONTEXT(), privateKey, SWIGV8_BOOLEAN_NEW(true));

  obj->SetAlignedPointerInInternalField(0, cdata);

  cdata->handle.Reset(v8::Isolate::GetCurrent(), obj);

  cdata->handle.SetWeak(cdata, _wrap_SwigV8PackedData_delete, v8::WeakCallbackType::kParameter);

#if (SWIG_V8_VERSION < 0x0704)
  cdata->handle.MarkIndependent();
// Looks like future versions do not require that anymore:
// https://monorail-prod.appspot.com/p/chromium/issues/detail?id=923361#c11
#endif

  SWIGV8_ESCAPE(obj);

}

#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIGV8_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type)                SWIGV8_NewPackedObj(ptr, sz, type)


/* ---------------------------------------------------------------------------
 * Support for IN/OUTPUT typemaps (see Lib/typemaps/inoutlist.swg)
 *
 * ---------------------------------------------------------------------------*/

SWIGRUNTIME

SWIGV8_VALUE SWIGV8_AppendOutput(SWIGV8_VALUE result, SWIGV8_VALUE obj) {
  SWIGV8_HANDLESCOPE_ESC();
  
  if (result->IsUndefined()) {
    result = SWIGV8_ARRAY_NEW(0);
  } else if (!result->IsArray()) {
    SWIGV8_ARRAY tmparr = SWIGV8_ARRAY_NEW(0);
    SWIGV8_ARRAY_SET(tmparr, 0, result);
    result = tmparr;
  }

  SWIGV8_ARRAY arr = SWIGV8_ARRAY::Cast(result);
  SWIGV8_ARRAY_SET(arr, arr->Length(), obj);
  SWIGV8_ESCAPE(arr);
}



typedef v8::FunctionCallback            SwigV8FunctionCallback;
typedef v8::AccessorNameGetterCallback  SwigV8AccessorGetterCallback;
typedef v8::AccessorNameSetterCallback  SwigV8AccessorSetterCallback;
typedef v8::PropertyCallbackInfo<void>  SwigV8PropertyCallbackInfoVoid;

/**
 * Creates a class template for a class with specified initialization function.
 */
SWIGRUNTIME SWIGV8_FUNCTION_TEMPLATE SWIGV8_CreateClassTemplate(const char* symbol) {
    SWIGV8_HANDLESCOPE_ESC();
    
    v8::Local<v8::FunctionTemplate> class_templ = SWIGV8_FUNCTEMPLATE_NEW_VOID();
    class_templ->SetClassName(SWIGV8_SYMBOL_NEW(symbol));

    SWIGV8_OBJECT_TEMPLATE inst_templ = class_templ->InstanceTemplate();
    inst_templ->SetInternalFieldCount(1);

    SWIGV8_OBJECT_TEMPLATE equals_templ = class_templ->PrototypeTemplate();
    equals_templ->Set(SWIGV8_SYMBOL_NEW("equals"), SWIGV8_FUNCTEMPLATE_NEW(_SWIGV8_wrap_equals));

    SWIGV8_OBJECT_TEMPLATE cptr_templ = class_templ->PrototypeTemplate();
    cptr_templ->Set(SWIGV8_SYMBOL_NEW("getCPtr"), SWIGV8_FUNCTEMPLATE_NEW(_wrap_getCPtr));

    SWIGV8_ESCAPE(class_templ);
}

/**
 * Registers a class method with given name for a given class template.
 */
SWIGRUNTIME void SWIGV8_AddMemberFunction(SWIGV8_FUNCTION_TEMPLATE class_templ, const char* symbol,
  SwigV8FunctionCallback _func) {
    SWIGV8_OBJECT_TEMPLATE proto_templ = class_templ->PrototypeTemplate();
    proto_templ->Set(SWIGV8_SYMBOL_NEW(symbol), SWIGV8_FUNCTEMPLATE_NEW(_func));
}

/**
 * Registers a class property with given name for a given class template.
 */
SWIGRUNTIME void SWIGV8_AddMemberVariable(SWIGV8_FUNCTION_TEMPLATE class_templ, const char* symbol,
  SwigV8AccessorGetterCallback getter, SwigV8AccessorSetterCallback setter) {
  SWIGV8_OBJECT_TEMPLATE proto_templ = class_templ->InstanceTemplate();
  proto_templ->SetAccessor(SWIGV8_SYMBOL_NEW(symbol), getter, setter);
}

/**
 * Registers a class method with given name for a given object.
 */
SWIGRUNTIME void SWIGV8_AddStaticFunction(SWIGV8_OBJECT obj, const char* symbol,
  const SwigV8FunctionCallback& _func, v8::Local<v8::Context> context) {
  SWIGV8_MAYBE_CHECK(obj->Set(context, SWIGV8_SYMBOL_NEW(symbol), SWIGV8_FUNCTEMPLATE_NEW(_func)->GetFunction(context).ToLocalChecked()));
}

/**
 * Registers a class method with given name for a given object.
 */
SWIGRUNTIME void SWIGV8_AddStaticVariable(SWIGV8_OBJECT obj, const char* symbol,
  SwigV8AccessorGetterCallback getter, SwigV8AccessorSetterCallback setter,
  v8::Local<v8::Context> context) {
  SWIGV8_MAYBE_CHECK(obj->SetAccessor(context, SWIGV8_SYMBOL_NEW(symbol), getter, setter));
}

SWIGRUNTIME void JS_veto_set_variable(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid& info)
{
    char buffer[256];
    char msg[512];
    int res;

    v8::Local<v8::String> sproperty;
    if (property->ToString(SWIGV8_CURRENT_CONTEXT()).ToLocal(&sproperty)) {
      SWIGV8_WRITE_UTF8(sproperty, buffer, 256);
      res = SWIG_snprintf(msg, sizeof(msg), "Tried to write read-only variable: %s.", buffer);
    }
    else {
      res = -1;
    }

    if(res<0) {
      SWIG_exception(SWIG_ERROR, "Tried to write read-only variable.");
    } else {
      SWIG_exception(SWIG_ERROR, msg);
    }
fail: ;
}



/* -------- TYPES TABLE (BEGIN) -------- */

#define SWIGTYPE_p_FILE swig_types[0]
#define SWIGTYPE_p__htmlElemDesc swig_types[1]
#define SWIGTYPE_p__htmlEntityDesc swig_types[2]
#define SWIGTYPE_p__xlinkHandler swig_types[3]
#define SWIGTYPE_p__xmlAttr swig_types[4]
#define SWIGTYPE_p__xmlAttrHashBucket swig_types[5]
#define SWIGTYPE_p__xmlAttribute swig_types[6]
#define SWIGTYPE_p__xmlAutomata swig_types[7]
#define SWIGTYPE_p__xmlAutomataState swig_types[8]
#define SWIGTYPE_p__xmlBuf swig_types[9]
#define SWIGTYPE_p__xmlBuffer swig_types[10]
#define SWIGTYPE_p__xmlCatalog swig_types[11]
#define SWIGTYPE_p__xmlChLRange swig_types[12]
#define SWIGTYPE_p__xmlChRangeGroup swig_types[13]
#define SWIGTYPE_p__xmlChSRange swig_types[14]
#define SWIGTYPE_p__xmlCharEncodingHandler swig_types[15]
#define SWIGTYPE_p__xmlDOMWrapCtxt swig_types[16]
#define SWIGTYPE_p__xmlDict swig_types[17]
#define SWIGTYPE_p__xmlDoc swig_types[18]
#define SWIGTYPE_p__xmlDtd swig_types[19]
#define SWIGTYPE_p__xmlElement swig_types[20]
#define SWIGTYPE_p__xmlElementContent swig_types[21]
#define SWIGTYPE_p__xmlEntity swig_types[22]
#define SWIGTYPE_p__xmlEnumeration swig_types[23]
#define SWIGTYPE_p__xmlError swig_types[24]
#define SWIGTYPE_p__xmlGlobalState swig_types[25]
#define SWIGTYPE_p__xmlHashTable swig_types[26]
#define SWIGTYPE_p__xmlID swig_types[27]
#define SWIGTYPE_p__xmlLink swig_types[28]
#define SWIGTYPE_p__xmlList swig_types[29]
#define SWIGTYPE_p__xmlModule swig_types[30]
#define SWIGTYPE_p__xmlMutex swig_types[31]
#define SWIGTYPE_p__xmlNode swig_types[32]
#define SWIGTYPE_p__xmlNodeSet swig_types[33]
#define SWIGTYPE_p__xmlNotation swig_types[34]
#define SWIGTYPE_p__xmlNs swig_types[35]
#define SWIGTYPE_p__xmlOutputBuffer swig_types[36]
#define SWIGTYPE_p__xmlParserCtxt swig_types[37]
#define SWIGTYPE_p__xmlParserInput swig_types[38]
#define SWIGTYPE_p__xmlParserInputBuffer swig_types[39]
#define SWIGTYPE_p__xmlParserNodeInfo swig_types[40]
#define SWIGTYPE_p__xmlParserNodeInfoSeq swig_types[41]
#define SWIGTYPE_p__xmlParserNsData swig_types[42]
#define SWIGTYPE_p__xmlPattern swig_types[43]
#define SWIGTYPE_p__xmlRMutex swig_types[44]
#define SWIGTYPE_p__xmlRef swig_types[45]
#define SWIGTYPE_p__xmlRegExecCtxt swig_types[46]
#define SWIGTYPE_p__xmlRegexp swig_types[47]
#define SWIGTYPE_p__xmlRelaxNG swig_types[48]
#define SWIGTYPE_p__xmlRelaxNGParserCtxt swig_types[49]
#define SWIGTYPE_p__xmlRelaxNGValidCtxt swig_types[50]
#define SWIGTYPE_p__xmlSAXHandler swig_types[51]
#define SWIGTYPE_p__xmlSAXHandlerV1 swig_types[52]
#define SWIGTYPE_p__xmlSAXLocator swig_types[53]
#define SWIGTYPE_p__xmlSaveCtxt swig_types[54]
#define SWIGTYPE_p__xmlSchema swig_types[55]
#define SWIGTYPE_p__xmlSchemaAnnot swig_types[56]
#define SWIGTYPE_p__xmlSchemaAttribute swig_types[57]
#define SWIGTYPE_p__xmlSchemaAttributeGroup swig_types[58]
#define SWIGTYPE_p__xmlSchemaAttributeLink swig_types[59]
#define SWIGTYPE_p__xmlSchemaElement swig_types[60]
#define SWIGTYPE_p__xmlSchemaFacet swig_types[61]
#define SWIGTYPE_p__xmlSchemaFacetLink swig_types[62]
#define SWIGTYPE_p__xmlSchemaNotation swig_types[63]
#define SWIGTYPE_p__xmlSchemaParserCtxt swig_types[64]
#define SWIGTYPE_p__xmlSchemaSAXPlug swig_types[65]
#define SWIGTYPE_p__xmlSchemaType swig_types[66]
#define SWIGTYPE_p__xmlSchemaTypeLink swig_types[67]
#define SWIGTYPE_p__xmlSchemaVal swig_types[68]
#define SWIGTYPE_p__xmlSchemaValidCtxt swig_types[69]
#define SWIGTYPE_p__xmlSchemaWildcard swig_types[70]
#define SWIGTYPE_p__xmlSchemaWildcardNs swig_types[71]
#define SWIGTYPE_p__xmlStartTag swig_types[72]
#define SWIGTYPE_p__xmlStreamCtxt swig_types[73]
#define SWIGTYPE_p__xmlTextReader swig_types[74]
#define SWIGTYPE_p__xmlTextWriter swig_types[75]
#define SWIGTYPE_p__xmlURI swig_types[76]
#define SWIGTYPE_p__xmlValidCtxt swig_types[77]
#define SWIGTYPE_p__xmlValidState swig_types[78]
#define SWIGTYPE_p__xmlXIncludeCtxt swig_types[79]
#define SWIGTYPE_p__xmlXPathAxis swig_types[80]
#define SWIGTYPE_p__xmlXPathCompExpr swig_types[81]
#define SWIGTYPE_p__xmlXPathContext swig_types[82]
#define SWIGTYPE_p__xmlXPathFunct swig_types[83]
#define SWIGTYPE_p__xmlXPathObject swig_types[84]
#define SWIGTYPE_p__xmlXPathParserContext swig_types[85]
#define SWIGTYPE_p__xmlXPathType swig_types[86]
#define SWIGTYPE_p__xmlXPathVariable swig_types[87]
#define SWIGTYPE_p_char swig_types[88]
#define SWIGTYPE_p_f_p__xmlLink__void swig_types[89]
#define SWIGTYPE_p_f_p__xmlNode__void swig_types[90]
#define SWIGTYPE_p_f_p__xmlRegExecCtxt_p_q_const__unsigned_char_p_void_p_void__void swig_types[91]
#define SWIGTYPE_p_f_p__xmlXPathObject_int__int swig_types[92]
#define SWIGTYPE_p_f_p__xmlXPathParserContext_int__void swig_types[93]
#define SWIGTYPE_p_f_p_q_const__char__int swig_types[94]
#define SWIGTYPE_p_f_p_q_const__char__p_char swig_types[95]
#define SWIGTYPE_p_f_p_q_const__char__p_void swig_types[96]
#define SWIGTYPE_p_f_p_q_const__char_p_q_const__char_xmlParserCtxtPtr__p__xmlParserInput swig_types[97]
#define SWIGTYPE_p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer swig_types[98]
#define SWIGTYPE_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer swig_types[99]
#define SWIGTYPE_p_f_p_q_const__void_p_q_const__void__int swig_types[100]
#define SWIGTYPE_p_f_p_q_const__void_p_void__int swig_types[101]
#define SWIGTYPE_p_f_p_unsigned_char__void swig_types[102]
#define SWIGTYPE_p_f_p_unsigned_char_p_int_p_q_const__unsigned_char_p_int__int swig_types[103]
#define SWIGTYPE_p_f_p_void__int swig_types[104]
#define SWIGTYPE_p_f_p_void__p_unsigned_char swig_types[105]
#define SWIGTYPE_p_f_p_void__void swig_types[106]
#define SWIGTYPE_p_f_p_void_p__xmlNode__void swig_types[107]
#define SWIGTYPE_p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void swig_types[108]
#define SWIGTYPE_p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_p_enum_xlinkShow_p_enum_xlinkActuate_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void swig_types[109]
#define SWIGTYPE_p_f_p_void_p__xmlNode_q_const__p_unsigned_char_q_const__p_unsigned_char_q_const__p_unsigned_char__void swig_types[110]
#define SWIGTYPE_p_f_p_void_p__xmlSAXLocator__void swig_types[111]
#define SWIGTYPE_p_f_p_void_p_char_int__int swig_types[112]
#define SWIGTYPE_p_f_p_void_p_p_q_const__char_p_unsigned_long__int swig_types[113]
#define SWIGTYPE_p_f_p_void_p_q_const___xmlError__void swig_types[114]
#define SWIGTYPE_p_f_p_void_p_q_const__char_enum_xmlParserSeverities_p_void__void swig_types[115]
#define SWIGTYPE_p_f_p_void_p_q_const__char_int__int swig_types[116]
#define SWIGTYPE_p_f_p_void_p_q_const__char_v_______void swig_types[117]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__p_void swig_types[118]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void swig_types[119]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int__void swig_types[120]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int_p__xmlElementContent__void swig_types[121]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int_p_q_const__unsigned_char_p_q_const__unsigned_char_p_unsigned_char__void swig_types[122]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_p_q_const__unsigned_char__void swig_types[123]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__p_f_p__xmlXPathParserContext_int__void swig_types[124]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__void swig_types[125]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_int_int_p_q_const__unsigned_char_p__xmlEnumeration__void swig_types[126]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void swig_types[127]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_int_p_p_q_const__unsigned_char_int_int_p_p_q_const__unsigned_char__void swig_types[128]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void swig_types[129]
#define SWIGTYPE_p_f_p_void_p_q_const__xmlChar__p__xmlEntity swig_types[130]
#define SWIGTYPE_p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlParserInput swig_types[131]
#define SWIGTYPE_p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlXPathObject swig_types[132]
#define SWIGTYPE_p_f_p_void_p_void_p_q_const__unsigned_char__void swig_types[133]
#define SWIGTYPE_p_f_p_void_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void swig_types[134]
#define SWIGTYPE_p_f_p_void_size_t__p_void swig_types[135]
#define SWIGTYPE_p_f_size_t__p_void swig_types[136]
#define SWIGTYPE_p_f_xmlDOMWrapCtxtPtr_xmlNodePtr_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlNs swig_types[137]
#define SWIGTYPE_p_f_xmlXPathParserContextPtr_xmlXPathObjectPtr__p__xmlXPathObject swig_types[138]
#define SWIGTYPE_p_htmlParserOption swig_types[139]
#define SWIGTYPE_p_htmlStatus swig_types[140]
#define SWIGTYPE_p_iconv_t swig_types[141]
#define SWIGTYPE_p_int swig_types[142]
#define SWIGTYPE_p_p__xmlCharEncodingHandler swig_types[143]
#define SWIGTYPE_p_p__xmlDoc swig_types[144]
#define SWIGTYPE_p_p__xmlElementContent swig_types[145]
#define SWIGTYPE_p_p__xmlEntity swig_types[146]
#define SWIGTYPE_p_p__xmlEnumeration swig_types[147]
#define SWIGTYPE_p_p__xmlNode swig_types[148]
#define SWIGTYPE_p_p__xmlNs swig_types[149]
#define SWIGTYPE_p_p__xmlParserCtxt swig_types[150]
#define SWIGTYPE_p_p__xmlParserInput swig_types[151]
#define SWIGTYPE_p_p__xmlPattern swig_types[152]
#define SWIGTYPE_p_p__xmlSAXHandler swig_types[153]
#define SWIGTYPE_p_p__xmlSchemaAttributeLink swig_types[154]
#define SWIGTYPE_p_p__xmlSchemaVal swig_types[155]
#define SWIGTYPE_p_p__xmlURI swig_types[156]
#define SWIGTYPE_p_p__xmlXPathObject swig_types[157]
#define SWIGTYPE_p_p_char swig_types[158]
#define SWIGTYPE_p_p_f_p__xmlNode__void swig_types[159]
#define SWIGTYPE_p_p_f_p_q_const__char__p_char swig_types[160]
#define SWIGTYPE_p_p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer swig_types[161]
#define SWIGTYPE_p_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer swig_types[162]
#define SWIGTYPE_p_p_f_p_void__void swig_types[163]
#define SWIGTYPE_p_p_f_p_void_p_q_const___xmlError__void swig_types[164]
#define SWIGTYPE_p_p_f_p_void_p_q_const__char_enum_xmlParserSeverities_p_void__void swig_types[165]
#define SWIGTYPE_p_p_f_p_void_p_q_const__char_v_______void swig_types[166]
#define SWIGTYPE_p_p_f_p_void_size_t__p_void swig_types[167]
#define SWIGTYPE_p_p_f_size_t__p_void swig_types[168]
#define SWIGTYPE_p_p_p__xmlNs swig_types[169]
#define SWIGTYPE_p_p_unsigned_char swig_types[170]
#define SWIGTYPE_p_p_void swig_types[171]
#define SWIGTYPE_p_unsigned_char swig_types[172]
#define SWIGTYPE_p_unsigned_int swig_types[173]
#define SWIGTYPE_p_unsigned_long swig_types[174]
#define SWIGTYPE_p_void swig_types[175]
#define SWIGTYPE_p_xlinkActuate swig_types[176]
#define SWIGTYPE_p_xlinkShow swig_types[177]
#define SWIGTYPE_p_xlinkType swig_types[178]
#define SWIGTYPE_p_xmlAttributeDefault swig_types[179]
#define SWIGTYPE_p_xmlAttributeType swig_types[180]
#define SWIGTYPE_p_xmlBufferAllocationScheme swig_types[181]
#define SWIGTYPE_p_xmlCatalogAllow swig_types[182]
#define SWIGTYPE_p_xmlCatalogPrefer swig_types[183]
#define SWIGTYPE_p_xmlCharEncError swig_types[184]
#define SWIGTYPE_p_xmlCharEncoding swig_types[185]
#define SWIGTYPE_p_xmlDocProperties swig_types[186]
#define SWIGTYPE_p_xmlElementContentOccur swig_types[187]
#define SWIGTYPE_p_xmlElementContentType swig_types[188]
#define SWIGTYPE_p_xmlElementType swig_types[189]
#define SWIGTYPE_p_xmlElementTypeVal swig_types[190]
#define SWIGTYPE_p_xmlEntityType swig_types[191]
#define SWIGTYPE_p_xmlErrorDomain swig_types[192]
#define SWIGTYPE_p_xmlErrorLevel swig_types[193]
#define SWIGTYPE_p_xmlFeature swig_types[194]
#define SWIGTYPE_p_xmlModuleOption swig_types[195]
#define SWIGTYPE_p_xmlParserErrors swig_types[196]
#define SWIGTYPE_p_xmlParserInputState swig_types[197]
#define SWIGTYPE_p_xmlParserMode swig_types[198]
#define SWIGTYPE_p_xmlParserOption swig_types[199]
#define SWIGTYPE_p_xmlParserProperties swig_types[200]
#define SWIGTYPE_p_xmlParserSeverities swig_types[201]
#define SWIGTYPE_p_xmlPatternFlags swig_types[202]
#define SWIGTYPE_p_xmlReaderTypes swig_types[203]
#define SWIGTYPE_p_xmlRelaxNGParserFlag swig_types[204]
#define SWIGTYPE_p_xmlRelaxNGValidErr swig_types[205]
#define SWIGTYPE_p_xmlSaveOption swig_types[206]
#define SWIGTYPE_p_xmlSchemaContentType swig_types[207]
#define SWIGTYPE_p_xmlSchemaTypeType swig_types[208]
#define SWIGTYPE_p_xmlSchemaValType swig_types[209]
#define SWIGTYPE_p_xmlSchemaValidError swig_types[210]
#define SWIGTYPE_p_xmlSchemaValidOption swig_types[211]
#define SWIGTYPE_p_xmlSchemaWhitespaceValueType swig_types[212]
#define SWIGTYPE_p_xmlTextReaderMode swig_types[213]
#define SWIGTYPE_p_xmlXPathError swig_types[214]
#define SWIGTYPE_p_xmlXPathObjectType swig_types[215]
static swig_type_info *swig_types[217];
static swig_module_info swig_module = {swig_types, 216, 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) -------- */



#ifdef __cplusplus
#include <utility>
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigSmartPointer {
    T *ptr;
    SwigSmartPointer(T *p) : ptr(p) { }
    ~SwigSmartPointer() { delete ptr; }
    SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
    void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; }
#if __cplusplus >=201103L
  SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; }
  operator T&&() const { return std::move(*pointer.ptr); }
#else
  operator T&() const { return *pointer.ptr; }
#endif
  T *operator&() const { return pointer.ptr; }
  static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
};

/*
 * SwigValueInit() is a generic initialisation solution as the following approach:
 * 
 *       T c_result = T();
 * 
 * doesn't compile for all types for example:
 * 
 *       unsigned int c_result = unsigned int();
 */
template <typename T> T SwigValueInit() {
  return T();
}

#if __cplusplus >=201103L
# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
#else
# define SWIG_STD_MOVE(OBJ) OBJ
#endif

#endif


#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 


#include <stdexcept>


#include <assert.h>


SWIGINTERN
int SWIG_AsVal_int (SWIGV8_VALUE valRef, int* val)
{
  if (!valRef->IsNumber()) {
    return SWIG_TypeError;
  }
  if(val) *val = SWIGV8_INTEGER_VALUE(valRef);

  return SWIG_OK;
}


SWIGINTERNINLINE
SWIGV8_VALUE SWIG_From_int  (int value)
{
  return SWIGV8_INT32_NEW(value);
}


    #if defined(_WIN32) && defined(_MSC_VER)
    #if defined(IN_LIBXMLJS)
        #define LIBXMLJS_API __declspec(dllexport)
    #else
        #define LIBXMLJS_API __declspec(dllimport)
    #endif
    #else
    #define LIBXMLJS_API
    #endif

    int libxmljs_debug = 0;

    void setDebugEnable() {
        libxmljs_debug = 1;
    }

    void setDebugDisable() {
        libxmljs_debug = 0;
    }

    void set_string_field(v8::Local<v8::Object> obj,
            const char* name, const char* value) {
        Nan::HandleScope scope;
        if (!value) {
            return;
        }
        Nan::Set(obj, Nan::New<v8::String>(name).ToLocalChecked(), Nan::New<v8::String>(value, strlen(value)).ToLocalChecked());
    }

    void set_numeric_field(v8::Local<v8::Object> obj,
            const char* name, const int value) {
        Nan::HandleScope scope;
        Nan::Set(obj, Nan::New<v8::String>(name).ToLocalChecked(), Nan::New<v8::Int32>(value));
    }

    SWIGV8_Proxy* getSwigProxy(SWIGV8_OBJECT objRef) {
        #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031511)
            v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
            return ((SWIGV8_Proxy *) v8::External::Unwrap(cdataRef));
        #else
            return ((SWIGV8_Proxy *) objRef->GetAlignedPointerFromInternalField(0));
        #endif
    }

    void* getSwigCObjectPtr(SWIGV8_VALUE value) {
        SWIGV8_Proxy *cdata;

        if (value->IsNull()) {
            return NULL;
        }

        if (!value->IsObject()) {
            // SWIG_exception_fail(0, "!$input->IsObject()");
            return NULL;
        }

        SWIGV8_OBJECT objRef = SWIGV8_TO_OBJECT(value);

        if (objRef->InternalFieldCount() < 1) {
            // SWIG_exception_fail(0, "InternalFieldCount < 1");
            return NULL;
        }

        cdata = getSwigProxy(objRef);

        if (cdata == NULL) {
            return NULL;
        }

        return (void*) cdata->swigCObject;
    }

    swig_type_info* getSwigCObjectPtrInfo(SWIGV8_VALUE value) {
        SWIGV8_Proxy *cdata;

        if (value->IsNull()) {
            return NULL;
        }

        if (!value->IsObject()) {
            // SWIG_exception_fail(0, "!$input->IsObject()");
            return NULL;
        }

        SWIGV8_OBJECT objRef = SWIGV8_TO_OBJECT(value);

        if (objRef->InternalFieldCount() < 1) {
            // SWIG_exception_fail(0, "InternalFieldCount < 1");
            return NULL;
        }

        cdata = getSwigProxy(objRef);

        if (cdata == NULL) {
            return NULL;
        }

        return cdata->info;
    }

    xmlNode* xmlNodeGetParent(xmlNode* node) {
        if (node == NULL) {
            return NULL;
        }
        
        switch (node->type) {
            case XML_ENTITY_DECL: {
                xmlEntityPtr castedNode = (xmlEntityPtr) node;
                return (xmlNode*) castedNode->parent;
            }

            case XML_NAMESPACE_DECL: {
                // xmlNsPtr castedNode = (xmlNsPtr)(node);
                // return (xmlNode*) castedNode->context;
                return NULL;
            }

            case XML_DOCUMENT_NODE:
            case XML_DOCB_DOCUMENT_NODE:
            case XML_HTML_DOCUMENT_NODE: {
                return NULL;
            }

            case XML_ATTRIBUTE_NODE: {
                xmlAttrPtr castedNode = (xmlAttrPtr) node;
                return (xmlNode*) castedNode->parent;
            }

            case XML_DTD_NODE: {
                xmlDtdPtr castedNode = (xmlDtdPtr) node;

                if (castedNode->parent == NULL) {
                    return (xmlNode*) castedNode->doc;
                }

                return (xmlNode*) castedNode->parent;
            }

            case XML_ELEMENT_DECL: {
                xmlElementPtr castedNode = (xmlElementPtr) node;
                return (xmlNode*) castedNode->parent;
            }

            default: {
                // if (node->parent == NULL) {
                //     return (xmlNode*) node->doc;
                // }

                return (xmlNode*) node->parent;
            }
        }
    }

    swig_type_info* xmlNodeGetSwigPtrInfo(xmlNode* node) {
        if (node == NULL) {
            return SWIGTYPE_p__xmlNode;
        }

        switch (node->type) {
            // case XML_XINCLUDE_START:
            // case XML_XINCLUDE_END: {
            //     result = createWrap(node, NULL, SWIGTYPE_p__xmlNode);
            // }
            case XML_ENTITY_DECL: 
                return SWIGTYPE_p__xmlEntity;

            case XML_NAMESPACE_DECL:
                return SWIGTYPE_p__xmlNs;

            case XML_DOCUMENT_NODE:
                return SWIGTYPE_p__xmlDoc;

            case XML_HTML_DOCUMENT_NODE:
                return SWIGTYPE_p__xmlDoc;

            case XML_DOCB_DOCUMENT_NODE: 
                return SWIGTYPE_p__xmlDoc;

            case XML_ATTRIBUTE_NODE:
                return SWIGTYPE_p__xmlAttr;

            case XML_DTD_NODE:
                return SWIGTYPE_p__xmlDtd;

            case XML_ELEMENT_DECL:
                return SWIGTYPE_p__xmlElement;

            default:
                return SWIGTYPE_p__xmlNode;
        }
    }

    int countNamespaces(xmlNs* ns) {
        int count = 0;
        
        while (ns != NULL) {
            count++;

            ns = ns->next;
        }

        return count;
    }

    xmlNs* getNodeNamespace(xmlNode* node) {
        if ((node->type == XML_ELEMENT_NODE) ||
            (node->type == XML_ATTRIBUTE_NODE)) {
            return node->ns;
        }

        return NULL;
    }

    xmlNs* getNodeNamespaceDef(xmlNode* xml_obj) {
        if ((xml_obj->type == XML_DOCUMENT_NODE) ||
    #ifdef LIBXML_DOCB_ENABLED
            (xml_obj->type == XML_DOCB_DOCUMENT_NODE) ||
    #endif
            (xml_obj->type == XML_HTML_DOCUMENT_NODE)) {
            return ((xmlDoc*) xml_obj)->oldNs;
        } else if ((xml_obj->type == XML_ELEMENT_NODE) ||
                (xml_obj->type == XML_XINCLUDE_START) ||
                (xml_obj->type == XML_XINCLUDE_END)) {
            return xml_obj->nsDef;
        } else {
            return NULL;
        }
    }
    
    void setNodeNamespaceDef(xmlNode* xml_obj, xmlNs* newNs) {
        if (xml_obj == NULL) {
            return;
        }

        if (xml_obj->type == XML_NAMESPACE_DECL) {
            xmlNs* ns = (xmlNs*) xml_obj;

            while (ns->next != NULL) {
                ns = ns->next;
            }

            ns->next = newNs;
        } else if ((xml_obj->type == XML_DOCUMENT_NODE) ||
    #ifdef LIBXML_DOCB_ENABLED
            (xml_obj->type == XML_DOCB_DOCUMENT_NODE) ||
    #endif
            (xml_obj->type == XML_HTML_DOCUMENT_NODE)) {
            ((xmlDoc*) xml_obj)->oldNs = newNs;
        } else if ((xml_obj->type == XML_ELEMENT_NODE) ||
                (xml_obj->type == XML_XINCLUDE_START) ||
                (xml_obj->type == XML_XINCLUDE_END)) {
            xml_obj->nsDef = newNs;
        }
    }

    xmlNode* getChildAtIndex(xmlNode* node, int index) {
        if (node == NULL) {
            return NULL;
        }

        int currIndex = 0;
        xmlNode* child = node->children;

        while (child != NULL) {
            if (currIndex >= index) {
                break;
            }

            currIndex++;
            child = child->next;
        }

        return child;
    }


    // extern "C" {
    //     #include "dynbuf.h"
    // }

    // t_dynbuf* references = NULL;

    #define LIBXMLJS_ARGUMENT_TYPE_CHECK(arg, type, err)                          \
    if (!arg->type()) {                                                         \
        return Nan::ThrowTypeError(err);                                            \
    }

    class LIBXMLJS_API WorkerParent {
    public:
        WorkerParent();
        virtual ~WorkerParent();
    private:
        friend void adjustMem(ssize_t);
        ssize_t memAdjustments;
    };

    // An object of the following class must be created in the worker thread,
    // and kept alive as long as the worker interfaces with libxmljs.
    // It must eventually be destroyed while still in the worker thread.
    class LIBXMLJS_API WorkerSentinel {
    public:
        WorkerSentinel(WorkerParent& parent);
        virtual ~WorkerSentinel();
    private:
        friend void adjustMem(ssize_t);
        WorkerParent& parent;
    };

    // track how much memory libxml2 is using
    ssize_t xml_memory_used = 0; // Mainly for testing

    // track how many nodes haven't been freed
    int xml_node_count = 0;
    
    int xml_wrap_count = 0;

    int getMemUsed() {
        return xml_memory_used;
    }

    int getNodeCount() {
        return xml_node_count;
    }

    int getWrapCount() {
        return xml_wrap_count;
    }

    bool tlsInitialized = false;
    Nan::nauv_key_t tlsKey;
    bool isAsync = false; // Only set on V8 thread when no workers are running
    int numWorkers = 0; // Only access from V8 thread

    struct memHdr {
        size_t size;
        double data;
    };

    #define HDR_SIZE offsetof(memHdr, data)

    inline void* hdr2client(memHdr* hdr) {
        return static_cast<void*>(reinterpret_cast<char*>(hdr) + HDR_SIZE);
    }

    inline memHdr* client2hdr(void* client) {
        return reinterpret_cast<memHdr*>(static_cast<char*>(client) - HDR_SIZE);
    }

    int xml_memory_diff = 0;
    int xml_memory_last_change = 0;

    inline void actuallyAdjustMem(ssize_t diff)  {
        xml_memory_used += diff;
        xml_memory_diff += diff;

        // throttle calls to Nan::AdjustExternalMemory, which is very slow
        if (abs(xml_memory_diff) > xml_memory_last_change) {
            xml_memory_last_change = abs(xml_memory_diff);
            // printf("adjustMem %i - %i\n", xml_memory_diff, xml_memory_used);
            Nan::AdjustExternalMemory(xml_memory_diff);
            xml_memory_diff = 0;
        }
    }

    void adjustMem(ssize_t diff) {
        if (isAsync) {
            WorkerSentinel* worker =
                static_cast<WorkerSentinel*>(Nan::nauv_key_get(&tlsKey));

            if (worker) {
                worker->parent.memAdjustments += diff;
                return;
            }
        }
        // if v8 is no longer running, don't try to adjust memory
        // this happens when the v8 vm is shutdown and the program is exiting
        // our cleanup routines for libxml will be called (freeing memory)
        // but v8 is already offline and does not need to be informed
        // trying to adjust after shutdown will result in a fatal error
    #if (NODE_MODULE_VERSION > 14)
        if (v8::Isolate::GetCurrent() == 0 ||
            v8::Isolate::GetCurrent()->IsDead())  {
            return;
        }
    #elif (NODE_MODULE_VERSION > 0x000B)
        if (v8::Isolate::GetCurrent() == 0) {
            assert(diff <= 0);
            return;
        }
    #else
        if (v8::V8::IsDead()) {
            assert(diff <= 0);
            return;
        }
    #endif
        actuallyAdjustMem(diff);
    }

    void* xmlMemMallocWrap(size_t size) {
        if (libxmljs_debug) {
            printf("xmlMemMallocWrap\n");
        }
        size_t totalSize = size + HDR_SIZE;
        memHdr* mem = static_cast<memHdr*>(malloc(totalSize));
        if (!mem) return NULL;
        mem->size = size;
        adjustMem(totalSize);
        return hdr2client(mem);
    }

    void xmlMemFreeWrap(void* p) {
        if (p == NULL) {
            return;
        }
        if (libxmljs_debug) {
            printf("xmlMemFreeWrap\n");
        }
        memHdr* mem = client2hdr(p);
        ssize_t totalSize = mem->size + HDR_SIZE;
        adjustMem(-totalSize);
        free(mem);
    }

    void* xmlMemReallocWrap(void* ptr, size_t size) {
        if (libxmljs_debug) {
            printf("xmlMemReallocWrap\n");
        }
        if (!ptr) return xmlMemMallocWrap(size);
        memHdr* mem1 = client2hdr(ptr);
        ssize_t oldSize = mem1->size;
        memHdr* mem2 = static_cast<memHdr*>(realloc(mem1, size + HDR_SIZE));
        if (!mem2) return NULL;
        mem2->size = size;
        adjustMem(ssize_t(size) - oldSize);
        return hdr2client(mem2);
    }

    char* xmlMemoryStrdupWrap(const char* str) {
        if (libxmljs_debug) {
            printf("xmlMemoryStrdupWrap\n");
        }
        size_t size = strlen(str) + 1;
        char* res = static_cast<char*>(xmlMemMallocWrap(size));
        if (res) memcpy(res, str, size);
        return res;
    }

        // // wrapper for xmlMemMalloc to update v8's knowledge of memory used
        // // the GC relies on this information
        // void* xmlMemMallocWrap(size_t size)
        // {
        //     void* res = xmlMemMalloc(size);

        //     // no need to udpate memory if we didn't allocate
        //     if (!res)
        //     {
        //         return res;
        //     }

        //     const int diff = xmlMemUsed() - xml_memory_used;
        //     // xml_memory_used += diff;
        //     // Nan::AdjustExternalMemory(diff);
        //     adjustMem(diff);
        //     return res;
        // }

        // // wrapper for xmlMemFree to update v8's knowledge of memory used
        // // the GC relies on this information
        // void xmlMemFreeWrap(void* p)
        // {
        //     xmlMemFree(p);

        //     // if v8 is no longer running, don't try to adjust memory
        //     // this happens when the v8 vm is shutdown and the program is exiting
        //     // our cleanup routines for libxml will be called (freeing memory)
        //     // but v8 is already offline and does not need to be informed
        //     // trying to adjust after shutdown will result in a fatal error
        // #if (NODE_MODULE_VERSION > 14)
        //     if (v8::Isolate::GetCurrent() == 0 ||
        //         v8::Isolate::GetCurrent()->IsDead())
        //     {
        //         return;
        //     }
        // #elif (NODE_MODULE_VERSION > 0x000B)
        //     if (v8::Isolate::GetCurrent() == 0)
        //     {
        //         return;
        //     }
        // #else
        //     if (v8::V8::IsDead())
        //     {
        //         return;
        //     }
        // #endif

        //     const int diff = xmlMemUsed() - xml_memory_used;
        //     // xml_memory_used += diff;
        //     // Nan::AdjustExternalMemory(diff);
        //     adjustMem(diff);
        // }

        // // wrapper for xmlMemRealloc to update v8's knowledge of memory used
        // void* xmlMemReallocWrap(void* ptr, size_t size)
        // {
        //     void* res = xmlMemRealloc(ptr, size);

        //     // if realloc fails, no need to update v8 memory state
        //     if (!res)
        //     {
        //         return res;
        //     }

        //     const int diff = xmlMemUsed() - xml_memory_used;
        //     // xml_memory_used += diff;
        //     // Nan::AdjustExternalMemory(diff);
        //     adjustMem(diff);
        //     return res;
        // }

        // // wrapper for xmlMemoryStrdupWrap to update v8's knowledge of memory used
        // char* xmlMemoryStrdupWrap(const char* str)
        // {
        //     char* res = xmlMemoryStrdup(str);

        //     // if strdup fails, no need to update v8 memory state
        //     if (!res)
        //     {
        //         return res;
        //     }

        //     const int diff = xmlMemUsed() - xml_memory_used;
        //     // xml_memory_used += diff;
        //     // Nan::AdjustExternalMemory(diff);
        //     adjustMem(diff);
        //     return res;
        // }


    // Set up in V8 thread
    WorkerParent::WorkerParent() : memAdjustments(0) {
        if (!tlsInitialized)
        {
            Nan::nauv_key_create(&tlsKey);
            tlsInitialized = true;
        }
        if (numWorkers++ == 0)
        {
            isAsync = true;
        }
    }

    // Tear down in V8 thread
    WorkerParent::~WorkerParent() {
        actuallyAdjustMem(memAdjustments);
        if (--numWorkers == 0)
        {
            isAsync = false;
        }
    }

    // Set up in worker thread
    WorkerSentinel::WorkerSentinel(WorkerParent& parent) : parent(parent) {
        Nan::nauv_key_set(&tlsKey, this);
        xmlMemSetup(xmlMemFreeWrap, xmlMemMallocWrap, xmlMemReallocWrap, xmlMemoryStrdupWrap);
    }

    // Tear down in worker thread
    WorkerSentinel::~WorkerSentinel() {
        Nan::nauv_key_set(&tlsKey, NULL);
    }

      int _xmlNode__private_get(_xmlNode* self) {          return 0;     }      int _xmlNode__private_set(_xmlNode* self, int value) {          return 0;      }  
      xmlElementType _xmlNode_type_get(_xmlNode* self) {          if (self == NULL) {              return (xmlElementType) 0;          }                   return self->type;     }  
      const xmlChar * _xmlNode_name_get(_xmlNode* self) {          if (self == NULL) {              return (const xmlChar *) 0;          }                   return self->name;     }  
      _xmlNode * _xmlNode_children_get(_xmlNode* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->children;     }  
      _xmlNode * _xmlNode_last_get(_xmlNode* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->last;     }  
      _xmlNode * _xmlNode_parent_get(_xmlNode* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->parent;     }  
      _xmlNode * _xmlNode_next_get(_xmlNode* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->next;     }  
      _xmlNode * _xmlNode_prev_get(_xmlNode* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->prev;     }  
      _xmlDoc * _xmlNode_doc_get(_xmlNode* self) {          if (self == NULL) {              return (_xmlDoc *) 0;          }                   return self->doc;     }  
      xmlNs * _xmlNode_ns_get(_xmlNode* self) {          if (self == NULL) {              return (xmlNs *) 0;          }                   return getNodeNamespace(self);     }  
      xmlChar * _xmlNode_content_get(_xmlNode* self) {          if (self == NULL) {              return (xmlChar *) 0;          }                   return self->content;     }  
      _xmlAttr * _xmlNode_properties_get(_xmlNode* self) {          if (self == NULL) {              return (_xmlAttr *) 0;          }                   return self->properties;     }  
      xmlNs * _xmlNode_nsDef_get(_xmlNode* self) {          if (self == NULL) {              return (xmlNs *) 0;          }                   return self->nsDef;     }  
      void * _xmlNode_psvi_get(_xmlNode* self) {          if (self == NULL) {              return (void *) 0;          }                   return self->psvi;     }  
      unsigned short _xmlNode_line_get(_xmlNode* self) {          if (self == NULL) {              return (unsigned short) 0;          }                   return self->line;     }  
      unsigned short _xmlNode_extra_get(_xmlNode* self) {          if (self == NULL) {              return (unsigned short) 0;          }                   return self->extra;     }  
      int _xmlElement__private_get(_xmlElement* self) {          return 0;     }      int _xmlElement__private_set(_xmlElement* self, int value) {          return 0;      }  
      xmlElementType _xmlElement_type_get(_xmlElement* self) {          if (self == NULL) {              return (xmlElementType) 0;          }                   return self->type;     }  
      const xmlChar * _xmlElement_name_get(_xmlElement* self) {          if (self == NULL) {              return (const xmlChar *) 0;          }                   return self->name;     }  
      _xmlNode * _xmlElement_children_get(_xmlElement* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->children;     }  
      _xmlNode * _xmlElement_last_get(_xmlElement* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->last;     }  
      _xmlDtd * _xmlElement_parent_get(_xmlElement* self) {          if (self == NULL) {              return (_xmlDtd *) 0;          }                   return self->parent;     }  
      _xmlNode * _xmlElement_next_get(_xmlElement* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->next;     }  
      _xmlNode * _xmlElement_prev_get(_xmlElement* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->prev;     }  
      _xmlDoc * _xmlElement_doc_get(_xmlElement* self) {          if (self == NULL) {              return (_xmlDoc *) 0;          }                   return self->doc;     }  
      xmlElementTypeVal _xmlElement_etype_get(_xmlElement* self) {          if (self == NULL) {              return (xmlElementTypeVal) 0;          }                   return self->etype;     }  
      xmlElementContentPtr _xmlElement_content_get(_xmlElement* self) {          if (self == NULL) {              return (xmlElementContentPtr) 0;          }                   return self->content;     }  
      xmlAttributePtr _xmlElement_attributes_get(_xmlElement* self) {          if (self == NULL) {              return (xmlAttributePtr) 0;          }                   return self->attributes;     }  
      const xmlChar * _xmlElement_prefix_get(_xmlElement* self) {          if (self == NULL) {              return (const xmlChar *) 0;          }                   return self->prefix;     }  
      xmlRegexpPtr _xmlElement_contModel_get(_xmlElement* self) {          if (self == NULL) {              return (xmlRegexpPtr) 0;          }                   return self->contModel;     }  
      int _xmlDoc__private_get(_xmlDoc* self) {          return 0;     }      int _xmlDoc__private_set(_xmlDoc* self, int value) {          return 0;      }  
      xmlElementType _xmlDoc_type_get(_xmlDoc* self) {          if (self == NULL) {              return (xmlElementType) 0;          }                   return self->type;     }  
      char * _xmlDoc_name_get(_xmlDoc* self) {          if (self == NULL) {              return (char *) 0;          }                   return self->name;     }  
      _xmlNode * _xmlDoc_children_get(_xmlDoc* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->children;     }  
      _xmlNode * _xmlDoc_last_get(_xmlDoc* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->last;     }  
      _xmlNode * _xmlDoc_parent_get(_xmlDoc* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->parent;     }  
      _xmlNode * _xmlDoc_next_get(_xmlDoc* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->next;     }  
      _xmlNode * _xmlDoc_prev_get(_xmlDoc* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->prev;     }  
      _xmlDoc * _xmlDoc_doc_get(_xmlDoc* self) {          if (self == NULL) {              return (_xmlDoc *) 0;          }                   return self->doc;     }  
      int _xmlDoc_compression_get(_xmlDoc* self) {          if (self == NULL) {              return (int) 0;          }                   return self->compression;     }  
      int _xmlDoc_standalone_get(_xmlDoc* self) {          if (self == NULL) {              return (int) 0;          }                   return self->standalone;     }  
      _xmlDtd * _xmlDoc_intSubset_get(_xmlDoc* self) {          if (self == NULL) {              return (_xmlDtd *) 0;          }                   return self->intSubset;     }  
      _xmlDtd * _xmlDoc_extSubset_get(_xmlDoc* self) {          if (self == NULL) {              return (_xmlDtd *) 0;          }                   return self->extSubset;     }  
      _xmlNs * _xmlDoc_oldNs_get(_xmlDoc* self) {          if (self == NULL) {              return (_xmlNs *) 0;          }                   return self->oldNs;     }  
      const xmlChar * _xmlDoc_version_get(_xmlDoc* self) {          if (self == NULL) {              return (const xmlChar *) 0;          }                   return self->version;     }  
      const xmlChar * _xmlDoc_encoding_get(_xmlDoc* self) {          if (self == NULL) {              return (const xmlChar *) 0;          }                   return self->encoding;     }  
      void * _xmlDoc_ids_get(_xmlDoc* self) {          if (self == NULL) {              return (void *) 0;          }                   return self->ids;     }  
      void * _xmlDoc_refs_get(_xmlDoc* self) {          if (self == NULL) {              return (void *) 0;          }                   return self->refs;     }  
      const xmlChar * _xmlDoc_URL_get(_xmlDoc* self) {          if (self == NULL) {              return (const xmlChar *) 0;          }                   return self->URL;     }  
      int _xmlDoc_charset_get(_xmlDoc* self) {          if (self == NULL) {              return (int) 0;          }                   return self->charset;     }  
      _xmlDict * _xmlDoc_dict_get(_xmlDoc* self) {          if (self == NULL) {              return (_xmlDict *) 0;          }                   return self->dict;     }  
      void * _xmlDoc_psvi_get(_xmlDoc* self) {          if (self == NULL) {              return (void *) 0;          }                   return self->psvi;     }  
      int _xmlDoc_parseFlags_get(_xmlDoc* self) {          if (self == NULL) {              return (int) 0;          }                   return self->parseFlags;     }  
      int _xmlDoc_properties_get(_xmlDoc* self) {          if (self == NULL) {              return (int) 0;          }                   return self->properties;     }  
      int _xmlAttr__private_get(_xmlAttr* self) {          return 0;     }      int _xmlAttr__private_set(_xmlAttr* self, int value) {          return 0;      }  
      xmlElementType _xmlAttr_type_get(_xmlAttr* self) {          if (self == NULL) {              return (xmlElementType) 0;          }                   return self->type;     }  
      const xmlChar * _xmlAttr_name_get(_xmlAttr* self) {          if (self == NULL) {              return (const xmlChar *) 0;          }                   return self->name;     }  
      _xmlNode * _xmlAttr_children_get(_xmlAttr* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->children;     }  
      _xmlNode * _xmlAttr_last_get(_xmlAttr* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->last;     }  
      _xmlNode * _xmlAttr_parent_get(_xmlAttr* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->parent;     }  
      _xmlAttr * _xmlAttr_next_get(_xmlAttr* self) {          if (self == NULL) {              return (_xmlAttr *) 0;          }                   return self->next;     }  
      _xmlAttr * _xmlAttr_prev_get(_xmlAttr* self) {          if (self == NULL) {              return (_xmlAttr *) 0;          }                   return self->prev;     }  
      _xmlDoc * _xmlAttr_doc_get(_xmlAttr* self) {          if (self == NULL) {              return (_xmlDoc *) 0;          }                   return self->doc;     }  
      xmlNs * _xmlAttr_ns_get(_xmlAttr* self) {          if (self == NULL) {              return (xmlNs *) 0;          }                   return self->ns;     }  
      xmlAttributeType _xmlAttr_atype_get(_xmlAttr* self) {          if (self == NULL) {              return (xmlAttributeType) 0;          }                   return self->atype;     }  
      void * _xmlAttr_psvi_get(_xmlAttr* self) {          if (self == NULL) {              return (void *) 0;          }                   return self->psvi;     }  
      int _xmlDtd__private_get(_xmlDtd* self) {          return 0;     }      int _xmlDtd__private_set(_xmlDtd* self, int value) {          return 0;      }  
      xmlElementType _xmlDtd_type_get(_xmlDtd* self) {          if (self == NULL) {              return (xmlElementType) 0;          }                   return self->type;     }  
      const xmlChar * _xmlDtd_name_get(_xmlDtd* self) {          if (self == NULL) {              return (const xmlChar *) 0;          }                   return self->name;     }  
      _xmlNode * _xmlDtd_children_get(_xmlDtd* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->children;     }  
      _xmlNode * _xmlDtd_last_get(_xmlDtd* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->last;     }  
      _xmlDoc * _xmlDtd_parent_get(_xmlDtd* self) {          if (self == NULL) {              return (_xmlDoc *) 0;          }                   return self->parent;     }  
      _xmlNode * _xmlDtd_next_get(_xmlDtd* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->next;     }  
      _xmlNode * _xmlDtd_prev_get(_xmlDtd* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->prev;     }  
      _xmlDoc * _xmlDtd_doc_get(_xmlDtd* self) {          if (self == NULL) {              return (_xmlDoc *) 0;          }                   return self->doc;     }  
      void * _xmlDtd_notations_get(_xmlDtd* self) {          if (self == NULL) {              return (void *) 0;          }                   return self->notations;     }  
      void * _xmlDtd_elements_get(_xmlDtd* self) {          if (self == NULL) {              return (void *) 0;          }                   return self->elements;     }  
      void * _xmlDtd_attributes_get(_xmlDtd* self) {          if (self == NULL) {              return (void *) 0;          }                   return self->attributes;     }  
      void * _xmlDtd_entities_get(_xmlDtd* self) {          if (self == NULL) {              return (void *) 0;          }                   return self->entities;     }  
      const xmlChar * _xmlDtd_ExternalID_get(_xmlDtd* self) {          if (self == NULL) {              return (const xmlChar *) 0;          }                   return self->ExternalID;     }  
      const xmlChar * _xmlDtd_SystemID_get(_xmlDtd* self) {          if (self == NULL) {              return (const xmlChar *) 0;          }                   return self->SystemID;     }  
      void * _xmlDtd_pentities_get(_xmlDtd* self) {          if (self == NULL) {              return (void *) 0;          }                   return self->pentities;     }  
      _xmlNs * _xmlNs_next_get(_xmlNs* self) {          if (self == NULL) {              return (_xmlNs *) 0;          }                   return self->next;     }  
      xmlNsType _xmlNs_type_get(_xmlNs* self) {          if (self == NULL) {              return (xmlNsType) 0;          }                   return self->type;     }  
      const xmlChar * _xmlNs_href_get(_xmlNs* self) {          if (self == NULL) {              return (const xmlChar *) 0;          }                   return self->href;     }  
      const xmlChar * _xmlNs_prefix_get(_xmlNs* self) {          if (self == NULL) {              return (const xmlChar *) 0;          }                   return self->prefix;     }  
      int _xmlNs__private_get(_xmlNs* self) {          return 0;     }      int _xmlNs__private_set(_xmlNs* self, int value) {          return 0;      }  
      _xmlDoc * _xmlNs_context_get(_xmlNs* self) {          if (self == NULL) {              return (_xmlDoc *) 0;          }                   return self->context;     }  
      int _xmlEntity__private_get(_xmlEntity* self) {          return 0;     }      int _xmlEntity__private_set(_xmlEntity* self, int value) {          return 0;      }  
      xmlElementType _xmlEntity_type_get(_xmlEntity* self) {          if (self == NULL) {              return (xmlElementType) 0;          }                   return self->type;     }  
      const xmlChar * _xmlEntity_name_get(_xmlEntity* self) {          if (self == NULL) {              return (const xmlChar *) 0;          }                   return self->name;     }  
      _xmlNode * _xmlEntity_children_get(_xmlEntity* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->children;     }  
      _xmlNode * _xmlEntity_last_get(_xmlEntity* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->last;     }  
      _xmlDtd * _xmlEntity_parent_get(_xmlEntity* self) {          if (self == NULL) {              return (_xmlDtd *) 0;          }                   return self->parent;     }  
      _xmlNode * _xmlEntity_next_get(_xmlEntity* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->next;     }  
      _xmlNode * _xmlEntity_prev_get(_xmlEntity* self) {          if (self == NULL) {              return (_xmlNode *) 0;          }                   return self->prev;     }  
      _xmlDoc * _xmlEntity_doc_get(_xmlEntity* self) {          if (self == NULL) {              return (_xmlDoc *) 0;          }                   return self->doc;     }  
      xmlChar * _xmlEntity_orig_get(_xmlEntity* self) {          if (self == NULL) {              return (xmlChar *) 0;          }                   return self->orig;     }  
      xmlChar * _xmlEntity_content_get(_xmlEntity* self) {          if (self == NULL) {              return (xmlChar *) 0;          }                   return self->content;     }  
      int _xmlEntity_length_get(_xmlEntity* self) {          if (self == NULL) {              return (int) 0;          }                   return self->length;     }  
      xmlEntityType _xmlEntity_etype_get(_xmlEntity* self) {          if (self == NULL) {              return (xmlEntityType) 0;          }                   return self->etype;     }  
      const xmlChar * _xmlEntity_ExternalID_get(_xmlEntity* self) {          if (self == NULL) {              return (const xmlChar *) 0;          }                   return self->ExternalID;     }  
      const xmlChar * _xmlEntity_SystemID_get(_xmlEntity* self) {          if (self == NULL) {              return (const xmlChar *) 0;          }                   return self->SystemID;     }  
      _xmlEntity * _xmlEntity_nexte_get(_xmlEntity* self) {          if (self == NULL) {              return (_xmlEntity *) 0;          }                   return self->nexte;     }  
      const xmlChar * _xmlEntity_URI_get(_xmlEntity* self) {          if (self == NULL) {              return (const xmlChar *) 0;          }                   return self->URI;     }  
      int _xmlEntity_owner_get(_xmlEntity* self) {          if (self == NULL) {              return (int) 0;          }                   return self->owner;     }  
      int _xmlEntity_checked_get(_xmlEntity* self) {          if (self == NULL) {              return (int) 0;          }                   return self->checked;     }  

SWIGINTERNINLINE
SWIGV8_VALUE
SWIG_From_bool  (bool value)
{
  return SWIGV8_BOOLEAN_NEW(value);
}


/*
 * Return the (non-document) root, or a wrapped ancestor: whichever is closest
 */
xmlNode*
get_wrapped_ancestor_or_root(xmlNode *xml_obj) {
    while ((xml_obj->parent != NULL) &&
           (((void*) xml_obj->doc) != ((void*) xml_obj->parent))  &&
           (xml_obj->parent->_private == NULL)) {
        xml_obj = xml_obj->parent;
    }
    return ((xml_obj->parent != NULL) &&
            (((void*) xml_obj->doc) != ((void*) xml_obj->parent))) ?
        xml_obj->parent : xml_obj;
}


/*
 * Search linked list for javascript wrapper, ignoring given node.
 */
xmlAttr*
get_wrapped_attr_in_list(xmlAttr *xml_obj, void *skip_xml_obj) {
    xmlAttr *wrapped_attr = NULL;
    while (xml_obj != NULL) {
        if ((xml_obj != skip_xml_obj) && (xml_obj->_private != NULL)) {
            wrapped_attr = xml_obj;
            xml_obj = NULL;
        }
        else {
            xml_obj = xml_obj->next;
        }
    }
    return wrapped_attr;
}

xmlNs*
get_wrapped_ns_in_list(xmlNs *xml_obj, void *skip_xml_obj) {
    xmlNs *wrapped_ns = NULL;
    while (xml_obj != NULL) {
        if ((xml_obj != skip_xml_obj) && (xml_obj->_private != NULL)) {
            wrapped_ns = xml_obj;
            xml_obj = NULL;
        }
        else {
            xml_obj = xml_obj->next;
        }
    }
    return wrapped_ns;
}

xmlNode* get_wrapped_node_in_children(xmlNode *xml_obj, xmlNode *skip_xml_obj);

/*
 * Search document for javascript wrapper, ignoring given node.
 * Based on xmlFreeDoc.
 */
xmlNode*
get_wrapped_node_in_document(xmlDoc *xml_obj, xmlNode *skip_xml_obj) {
    xmlNode *wrapped_node = NULL;
    if ((xml_obj->extSubset != NULL) &&
        (xml_obj->extSubset->_private != NULL) &&
        (((void*) xml_obj->extSubset) != skip_xml_obj)) {
        wrapped_node = ((xmlNode*) xml_obj->extSubset);
    }
    if ((wrapped_node == NULL) &&
        (xml_obj->intSubset != NULL) &&
        (xml_obj->intSubset->_private != NULL) &&
        (((void*) xml_obj->intSubset) != skip_xml_obj)) {
        wrapped_node = ((xmlNode*) xml_obj->intSubset);
    }
    if ((wrapped_node == NULL) && (xml_obj->children != NULL)) {
        wrapped_node =
            get_wrapped_node_in_children(xml_obj->children, skip_xml_obj);
    }
    if ((wrapped_node == NULL) && (xml_obj->oldNs != NULL)) {
        wrapped_node =
            ((xmlNode*) get_wrapped_ns_in_list(xml_obj->oldNs, skip_xml_obj));

    }
    return wrapped_node;
}

/*
 * Search children of node for javascript wrapper, ignoring given node.
 * Based on xmlFreeNodeList.
 */
xmlNode*
get_wrapped_node_in_children(xmlNode *xml_obj, xmlNode *skip_xml_obj) {

    xmlNode* wrapped_node = NULL;

    if (xml_obj->type == XML_NAMESPACE_DECL) {
        return ((xmlNode*) 
            get_wrapped_ns_in_list(((xmlNs*) xml_obj), skip_xml_obj)
        );
    }

    if ((xml_obj->type == XML_DOCUMENT_NODE) ||
#ifdef LIBXML_DOCB_ENABLED
        (xml_obj->type == XML_DOCB_DOCUMENT_NODE) ||
#endif
        (xml_obj->type == XML_HTML_DOCUMENT_NODE)) {
        return get_wrapped_node_in_document(((xmlDoc*) xml_obj), skip_xml_obj);
    }

    xmlNode *next;
    while (xml_obj != NULL) {
        next = xml_obj->next;

        if ((xml_obj != skip_xml_obj) && (xml_obj->_private != NULL)) {
            wrapped_node = xml_obj;
        }
        else {

            if ((xml_obj->children != NULL) && (xml_obj->type != XML_ENTITY_REF_NODE)) {
                wrapped_node = get_wrapped_node_in_children(xml_obj->children, skip_xml_obj);
            }

            if ((wrapped_node == NULL) &&
                ((xml_obj->type == XML_ELEMENT_NODE) ||
                 (xml_obj->type == XML_XINCLUDE_START) ||
                 (xml_obj->type == XML_XINCLUDE_END))) {

                if ((wrapped_node == NULL) && (xml_obj->properties != NULL)) {
                    wrapped_node =
                        ((xmlNode*) get_wrapped_attr_in_list(xml_obj->properties, skip_xml_obj));
                }

                if ((wrapped_node == NULL) && (xml_obj->nsDef != NULL)) {
                    wrapped_node =
                        ((xmlNode*) get_wrapped_ns_in_list(xml_obj->nsDef, skip_xml_obj));
                }
            }

        }

        if (wrapped_node != NULL) {
            break;
        }

        xml_obj = next;
    }

    return wrapped_node;
}

/*
 * Search descendants of node to find javascript wrapper,
 * optionally ignoring given node. Based on xmlFreeNode.
 */
xmlNode*
get_wrapped_descendant(xmlNode *xml_obj, xmlNode *skip_xml_obj=NULL) {

    xmlNode* wrapped_descendant = NULL;

    if (xml_obj->type == XML_DTD_NODE) {
        return (xml_obj->children == NULL) ?
            NULL : get_wrapped_node_in_children(xml_obj->children, skip_xml_obj);
    }

    if (xml_obj->type == XML_NAMESPACE_DECL) {
        return NULL;
    }

    if (xml_obj->type == XML_ATTRIBUTE_NODE) {
        return (xml_obj->children == NULL) ?
            NULL : get_wrapped_node_in_children(xml_obj->children, skip_xml_obj);
    }

    if ((xml_obj->children != NULL) && (xml_obj->type != XML_ENTITY_REF_NODE)) {
        wrapped_descendant =
            get_wrapped_node_in_children(xml_obj->children, skip_xml_obj);
    }

    if ((xml_obj->type == XML_ELEMENT_NODE) ||
        (xml_obj->type == XML_XINCLUDE_START) ||
        (xml_obj->type == XML_XINCLUDE_END)) {

        if ((wrapped_descendant == NULL) && (xml_obj->properties != NULL)) {
            wrapped_descendant =
                ((xmlNode*) get_wrapped_attr_in_list(xml_obj->properties, skip_xml_obj));
        }

        if ((wrapped_descendant == NULL) && (xml_obj->nsDef != NULL)) {
            wrapped_descendant =
                ((xmlNode*) get_wrapped_ns_in_list(xml_obj->nsDef, skip_xml_obj));
        }
    }

    return wrapped_descendant;
}

xmlNode* get_wrapped_ancestor(SWIGV8_Proxy* wrap, xmlNode* xml_obj) {
    xmlNode* ancestor = get_wrapped_ancestor_or_root(xml_obj);
    return ((xml_obj == ancestor) || (ancestor->_private == NULL)) ? NULL : ancestor;
}

void unref_wrapped_ancestor(SWIGV8_Proxy* wrap) {
    if ((wrap->ancestor != NULL) && (wrap->ancestor->_private != NULL)) {
        (((SWIGV8_Proxy*) wrap->ancestor->_private))->Unref();
    }
    wrap->ancestor = NULL;
}

void ref_wrapped_ancestor(SWIGV8_Proxy* wrap, xmlNode* xml_obj) {
    xmlNode* ancestor = get_wrapped_ancestor(wrap, xml_obj);

    // if our closest wrapped ancestor has changed then we either
    // got removed, added, or a closer ancestor was wrapped
    if (ancestor != wrap->ancestor) {
        unref_wrapped_ancestor(wrap);
        wrap->ancestor = ancestor;
    }

    if (wrap->ancestor != NULL) {
        SWIGV8_Proxy* node = ((SWIGV8_Proxy*) wrap->ancestor->_private);
        node->Ref();
    }
}

    // int nodeHasWrap(xmlNode* node);
    // int nodeHasChildWrap(xmlNode* node);

    // int nodeHasPropertyWrap(xmlNode* node) {
    //     if (node == NULL) {
    //         return 0;
    //     }
    //     if (node->type != XML_ELEMENT_NODE) {
    //         return 0;
    //     }

    //     xmlAttr* prop = node->properties;

    //     while (prop != NULL) {
    //         if (nodeHasWrap((xmlNode*) prop) || nodeHasChildWrap(prop->children)) {
    //             return 1;
    //         }

    //         prop = prop->next;
    //     }

    //     return 0;
    // }

    // int nodeHasWrap(xmlNode* node) {
    //     if (node == NULL) {
    //         return 0;
    //     }

    //     if (getXmlNodePrivate(node) != NULL) {
    //         return 1;
    //     } else if (nodeHasPropertyWrap(node)) {
    //         return 1;
    //     }

    //     return 0;
    // }

    // int nodeHasParentWrap(xmlNode* node) {
    //     if (node == NULL || node->type == XML_NAMESPACE_DECL) {
    //         return 0;
    //     }

    //     return nodeHasWrap(node->parent) || nodeHasParentWrap(node->parent);
    // }

    // int nodeHasChildWrap(xmlNode* node) {
    //     if (node == NULL || node->type == XML_NAMESPACE_DECL) {
    //         return 0;
    //     }

    //     xmlNode* child = node->children;

    //     while (child != NULL) {
    //         if (nodeHasWrap(child)) {
    //             return 1;
    //         }

    //         child = child->next;
    //     }

    //     child = node->children;

    //     while (child != NULL) {
    //         if (nodeHasChildWrap(child)) {
    //             return 1;
    //         }

    //         child = child->next;
    //     }

    //     return 0;
    // }

    // void freeNodeOrDoc(xmlNode* node) {
    //     if (node == NULL) {
    //         return;
    //     }

    //     while (node != NULL && node->parent != NULL) {
    //         node = node->parent;
    //     }
        
    //     if ((node->type == XML_DOCUMENT_NODE) ||
    //     #ifdef LIBXML_DOCB_ENABLED
    //     (node->type == XML_DOCB_DOCUMENT_NODE) ||
    //     #endif
    //     (node->type == XML_HTML_DOCUMENT_NODE)) {
    //         printf("freeing doc %i %i %i\n", node->type, xml_memory_used, xml_node_count);

    //         // xmlNode* root = xmlDocGetRootElement((xmlDocPtr) node);

    //         // if (root != NULL) {
    //         //     printf("xmlReconciliateNs\n");
    //         //     xmlReconciliateNs((xmlDocPtr) node, root);
    //         // }

    //         xmlFreeDoc((xmlDocPtr) node);
    //         printf("freed  doc %i %i %i\n", node->type, xml_memory_used, xml_node_count);
    //     } else if (node->type == XML_NAMESPACE_DECL) {
    //         xmlNs* ns = (xmlNs*) node;
    //         printf("freeing namespace %s %s %i\n", ns->href, ns->prefix, ns->context);

    //         // xmlFreeNs(ns);
    //     } else {
    //         printf("freeing node %i %i %i\n", node->type, xml_memory_used, xml_node_count);
            
    //         // if (node->type == XML_ELEMENT_NODE && node->doc) {
    //         //     printf("xmlReconciliateNs\n");
    //         //     xmlReconciliateNs(node->doc, node);
    //         // }

    //         xmlFreeNode(node);

    //         printf("freed  node %i %i %i\n", node->type, xml_memory_used, xml_node_count);
    //     }
    // }


    #include "assert.h"

    bool xmlDocHasRootElement(const xmlDoc *doc) {
        return xmlDocGetRootElement(doc) != NULL;
    }

    bool isDocumentNode(xmlNode* node) {
        return (node->type == XML_DOCUMENT_NODE || node->type == XML_HTML_DOCUMENT_NODE);
    }

    SWIGV8_Proxy* getXmlNodePrivate(xmlNode* node) {
        if (node == NULL) {
            return NULL;
        }

        if (node->type == XML_NAMESPACE_DECL) {
            xmlNs* ns = ((xmlNs*) node);

            return (SWIGV8_Proxy*) ns->_private;
        }

        return (SWIGV8_Proxy*) node->_private;
    }

    void setXmlNodePrivate(xmlNode* node, SWIGV8_Proxy* value) {
        if (node == NULL) {
            return;
        }

        if (node->type == XML_NAMESPACE_DECL) {
            xmlNs* ns = ((xmlNs*) node);

            ns->_private = (void*) value;
        }

        node->_private = (void*) value;
    }
    
    void xmlRegisterNodeCallback(xmlNode* node)  {
        xml_node_count++;

        // printf("xmlRegisterNodeCallback type: %i, count: %i, mem: %i\n", node->type, xml_node_count, xml_memory_used);
    }

    void resetWrap(SWIGV8_Proxy* wrap) {
        // printf("resetWrap\n");
        if (wrap == NULL || (!wrap->swigCMemOwn && wrap->swigCObject == NULL)) {
            return; // null or already reset wrap
        }

        wrap->swigCObject = NULL;
        wrap->swigCMemOwn = false;
        // wrap->handle.Reset();
        wrap->handle.Reset(v8::Isolate::GetCurrent(), SWIGV8_OBJECT_NEW());
    }

    void deregisterNsList(xmlNs* ns) {
        while (ns != NULL) {
            if (ns->_private != NULL) {
                resetWrap((SWIGV8_Proxy*) ns->_private);
            }

            ns = ns->next;
        }
    }

    void deregisterNodeNamespaces(xmlNode* xml_obj) {
        xmlNs* ns = NULL;
        if ((xml_obj->type == XML_DOCUMENT_NODE) ||
    #ifdef LIBXML_DOCB_ENABLED
            (xml_obj->type == XML_DOCB_DOCUMENT_NODE) ||
    #endif
            (xml_obj->type == XML_HTML_DOCUMENT_NODE)) {
            ns = ((xmlDoc*) xml_obj)->oldNs;
        }
        else if ((xml_obj->type == XML_ELEMENT_NODE) ||
                (xml_obj->type == XML_XINCLUDE_START) ||
                (xml_obj->type == XML_XINCLUDE_END)) {
            ns = xml_obj->nsDef;
        }
        if (ns != NULL) {
            deregisterNsList(ns);
        }
    }

    void xmlDeregisterNodeCallback(xmlNode* xml_obj)  {
        xml_node_count--;

        deregisterNodeNamespaces(xml_obj);

        SWIGV8_Proxy* wrap = getXmlNodePrivate(xml_obj);

        if (wrap != NULL) {
            // Node is being deleted before its wrap was destroyed
            resetWrap(wrap);
            // printf("xmlDeregisterNodeCallback freeing wrapped node %i\n", xml_obj->type);
        }

        // printf("xmlDeregisterNodeCallback type: %i, count: %i, mem: %i\n", xml_obj->type, xml_node_count, xml_memory_used);
    }

    void SWIGV8_Proxy::Ref() {
        // printf("ref %i, %i\n", this->swigCObject, refCount + 1);
        refCount++;
        handle.ClearWeak();
    };

    void SWIGV8_Proxy::Unref() {
        // printf("unref %i, %i\n", this->swigCObject, refCount - 1);
        if (--refCount < 1) {
            handle.SetWeak(this, ((SWIGV8_ClientData*)info->clientdata)->dtor, v8::WeakCallbackType::kParameter);
        }
    }

    void wrapDestructor(SWIGV8_Proxy* wrap, xmlNode* xml_obj) {
        SWIGV8_Proxy* docWrap = getXmlNodePrivate((xmlNode*) wrap->doc);

        if (docWrap != NULL) {
            docWrap->Unref();
        }

        unref_wrapped_ancestor(wrap);

        if (xml_obj != NULL) {
            // printf("wrapDestructor %i type: %i, count: %i, mem: %i\n", xml_obj, xml_obj->type, xml_wrap_count - 1, xml_memory_used);

            if (isDocumentNode(xml_obj)) {
                // printf("xmlFreeDoc %i - %i\n", xml_obj->type, xml_memory_used);
                xmlFreeDoc((xmlDoc*) xml_obj);
            } else {
                if (xml_obj->parent == NULL) {
                    // printf("PARENT NULL %i %i\n", xml_obj, get_wrapped_descendant(xml_obj));
                    if (get_wrapped_descendant(xml_obj) == NULL) {
                        // printf("xmlFreeNode %i - %i\n", xml_obj->type, xml_memory_used);
                        xmlFreeNode(xml_obj);
                    }
                } else {
                    // printf("PARENT NOT NULL %i %i\n", xml_obj, get_wrapped_ancestor_or_root(xml_obj));

                    xmlNode *ancestor = get_wrapped_ancestor_or_root(xml_obj);
                    if ((ancestor->_private == NULL) &&
                        (ancestor->parent == NULL) &&
                        (get_wrapped_descendant(ancestor, xml_obj) == NULL)) {
                        // printf("xmlFreeNode ancestor %i - %i\n", ancestor->type, xml_memory_used);
                        xmlFreeNode(ancestor);
                    }
                }
            }
        } else {
            // printf("wrapDestructor count: %i, mem: %i\n", xml_wrap_count - 1, xml_memory_used);
        }

        xml_wrap_count--;

    }
    
    void wrapConstructor(SWIGV8_Proxy* wrap, xmlNode* xml_obj) {
        wrap->ancestor = NULL;

        if (!isDocumentNode(xml_obj)) {
            wrap->doc = xml_obj->doc;

            SWIGV8_Proxy* docWrap = getXmlNodePrivate((xmlNode*) wrap->doc);

            if (docWrap != NULL) {
                docWrap->Ref();
            }

            ref_wrapped_ancestor(wrap, xml_obj);
        }

        xml_wrap_count++;

        // printf("wrapConstructor %i type: %i, count: %i, mem: %i\n", xml_obj, xml_obj->type, xml_wrap_count, xml_memory_used);
    }

    SWIGV8_VALUE createWrap(xmlNode* node, swig_type_info* info) {
        Nan::EscapableHandleScope scope;

        if (node == NULL) {
            v8::Local<v8::Primitive> result = SWIGV8_NULL();
            return scope.Escape(result);
        }

        // libxml won't call xmlRegisterNodeCallback on XML_HTML_DOCUMENT_NODE
        // if (node->type == XML_HTML_DOCUMENT_NODE && node->_private == NULL) {
            // xmlRegisterNodeCallback(node);
        // }

        SWIGV8_Proxy* wrap = getXmlNodePrivate(node);

        if (wrap == NULL || wrap->handle.IsEmpty()) {
            SWIGV8_VALUE value = SWIG_NewPointerObj((void*) node, info, SWIG_POINTER_OWN);

            SWIGV8_OBJECT object = SWIGV8_TO_OBJECT(value);

            wrap = getSwigProxy(object);

            wrapConstructor(wrap, node);

            setXmlNodePrivate(node, wrap);
        }

        assert(!wrap->handle.IsEmpty());

        return scope.Escape(Nan::New(wrap->handle));
    }

    SWIGV8_VALUE createWrapNs(xmlNs* ns, swig_type_info* info) {
        // printf("createWrapNs %i, mem: %i\n", ns, xml_memory_used);

        Nan::EscapableHandleScope scope;

        if (ns == NULL) {
            v8::Local<v8::Primitive> result = SWIGV8_NULL();
            return scope.Escape(result);
        }

        SWIGV8_Proxy* wrap = (SWIGV8_Proxy*) ns->_private;

        if (wrap == NULL || wrap->handle.IsEmpty()) {
            SWIGV8_VALUE value = SWIG_NewPointerObj((void*) ns, info, SWIG_POINTER_OWN);

            SWIGV8_OBJECT object = SWIGV8_TO_OBJECT(value);

            wrap = getSwigProxy(object);
            
            if ((ns->context) && (ns->context->_private != NULL)) {
                wrap->doc = ns->context;
                getXmlNodePrivate((xmlNode*) wrap->doc)->Ref();
            }

            ns->_private = wrap;
        }

        assert(!wrap->handle.IsEmpty());

        return scope.Escape(Nan::New(wrap->handle));
    }

    void destroyWrap(xmlNode* node) {
        SWIGV8_Proxy* wrap = getXmlNodePrivate(node);

        setXmlNodePrivate(node, NULL);

        wrapDestructor(wrap, node);
    }

    void _xmlUnlinkNode(xmlNodePtr cur) {
        // printf("unlink %i\n", cur);
        unref_wrapped_ancestor(getXmlNodePrivate(cur));
        xmlUnlinkNode(cur);
    }


    #include "xml_syntax_error.h"

    v8::Local<v8::Value>
    XmlSyntaxError::BuildSyntaxError(xmlError* error) {
        Nan::EscapableHandleScope scope;

        v8::Local<v8::Value> err = v8::Exception::Error(
                Nan::New<v8::String>(error->message).ToLocalChecked());
        v8::Local<v8::Object> out = v8::Local<v8::Object>::Cast(err);

        set_numeric_field(out, "domain", error->domain);
        set_numeric_field(out, "code", error->code);
        set_string_field(out, "message", error->message);
        set_numeric_field(out, "level", error->level);
        set_numeric_field(out, "column", error->int2);
        set_string_field(out, "file", error->file);
        set_numeric_field(out, "line", error->line);
        set_string_field(out, "str1", error->str1);
        set_string_field(out, "str2", error->str2);
        set_string_field(out, "str3", error->str3);

        // only add if we have something interesting
        if (error->int1) {
            set_numeric_field(out, "int1", error->int1);
        }
        
        return scope.Escape(err);
    }

    void
    XmlSyntaxError::PushToArray(void* errs, xmlError* error) {
        Nan::HandleScope scope;

        if (errs != NULL) {
            v8::Local<v8::Array> array = *reinterpret_cast<v8::Local<v8::Array>*>(errs);
            
            // push method for array
            v8::Local<v8::Function> push = v8::Local<v8::Function>::Cast(Nan::Get(array, Nan::New<v8::String>("push").ToLocalChecked()).ToLocalChecked());

            v8::Local<v8::Value> argv[1] = { 
                XmlSyntaxError::BuildSyntaxError(error)
                    // SWIG_NewPointerObj(SWIG_as_voidptr(error), SWIGTYPE_p__xmlError, 0 |  0 )
                };

            Nan::Call(push, array, 1, argv);
        } else {
            SWIGV8_THROW_EXCEPTION(v8::Exception::Error(SWIGV8_STRING_NEW(error->message)));
        }
    }

    void
    XmlSyntaxError::GenericPushToArray(void* errs, const char *msg, ...) {
        Nan::HandleScope scope;

        if (errs != NULL) {
            v8::Local<v8::Array> array = *reinterpret_cast<v8::Local<v8::Array>*>(errs);
            
            // push method for array
            v8::Local<v8::Function> push = v8::Local<v8::Function>::Cast(Nan::Get(array, Nan::New<v8::String>("push").ToLocalChecked()).ToLocalChecked());

            v8::Local<v8::Value> argv[1] = { SWIGV8_STRING_NEW(msg) };

            Nan::Call(push, array, 1, argv);
        } else {
            SWIGV8_THROW_EXCEPTION(v8::Exception::Error(SWIGV8_STRING_NEW(msg)));
        }
    }
    
    NAN_METHOD(withStructuredErrors) {
        Nan::HandleScope scope;

        auto array = SWIGV8_ARRAY_NEW(0);

        xmlSetStructuredErrorFunc(reinterpret_cast<void*>(&array), XmlSyntaxError::PushToArray);

        v8::Local<v8::Value> argv[1] = { array };

        auto callback = Nan::To<v8::Function>(info[0]).ToLocalChecked();
        
        auto ret = Nan::Call(callback, Nan::GetCurrentContext()->Global(), 1, argv);

        xmlSetStructuredErrorFunc(reinterpret_cast<void*>(NULL), XmlSyntaxError::PushToArray);

        if (ret.IsEmpty()) {
          return info.GetReturnValue().Set(SWIGV8_UNDEFINED());
        }

        return info.GetReturnValue().Set(ret.ToLocalChecked());
    }
    
    NAN_METHOD(withGenericErrors) {
        Nan::HandleScope scope;

        auto array = SWIGV8_ARRAY_NEW(0);

        xmlSetGenericErrorFunc(reinterpret_cast<void*>(&array), XmlSyntaxError::GenericPushToArray);

        v8::Local<v8::Value> argv[1] = { array };

        auto callback = Nan::To<v8::Function>(info[0]).ToLocalChecked();

        auto ret = Nan::Call(callback, Nan::GetCurrentContext()->Global(), 1, argv);

        xmlSetGenericErrorFunc(reinterpret_cast<void*>(NULL), XmlSyntaxError::GenericPushToArray);

        if (ret.IsEmpty()) {
          return info.GetReturnValue().Set(SWIGV8_UNDEFINED());
        }

        return info.GetReturnValue().Set(ret.ToLocalChecked());
    }


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


SWIGINTERNINLINE SWIGV8_VALUE
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  if (carray) {
    if (size > INT_MAX) {
      // TODO: handle extra long strings
      return SWIGV8_UNDEFINED();
    } else {
      v8::Local<v8::String> js_str = SWIGV8_STRING_NEW2(carray, size);
      return js_str;
    }
  } else {
    return SWIGV8_UNDEFINED();
  }
}


SWIGINTERNINLINE SWIGV8_VALUE 
SWIG_FromCharPtr(const char *cptr)
{ 
  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}


SWIGINTERN int
SWIG_AsCharPtrAndSize(SWIGV8_VALUE valRef, char** cptr, size_t* psize, int *alloc)
{
  if(valRef->IsString()) {
    v8::Local<v8::String> js_str = v8::Local<v8::String>::Cast(valRef);

    size_t len = SWIGV8_UTF8_LENGTH(js_str) + 1;
    char* cstr = (char*) (new char[len]());
    SWIGV8_WRITE_UTF8(js_str, cstr, len);
    
    if(alloc) *alloc = SWIG_NEWOBJ;
    if(psize) *psize = len;
    if(cptr) *cptr = cstr;
    
    return SWIG_OK;
  } else {
    if(valRef->IsObject()) {
      SWIGV8_OBJECT obj = SWIGV8_OBJECT::Cast(valRef);
      // try if the object is a wrapped char[]
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
      if (pchar_descriptor) {
        void* vptr = 0;
        if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
          if (cptr) *cptr = (char *) vptr;
          if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
          if (alloc) *alloc = SWIG_OLDOBJ;
          return SWIG_OK;
        }
      }
      return SWIG_TypeError;
    } else {
      return SWIG_TypeError;
    }
  }
}





#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_double (SWIGV8_VALUE obj, double *val)
{
  if(!obj->IsNumber()) {
    return SWIG_TypeError;
  }
  if(val) *val = SWIGV8_NUMBER_VALUE(obj);

  return SWIG_OK;
}


#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, cx, rd;
   errno = 0;
   fx = floor(x);
   cx = ceil(x);
   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 (SWIGV8_VALUE obj, unsigned long *val)
{
  if(!obj->IsNumber()) {
    return SWIG_TypeError;
  }

  long longVal = (long) SWIGV8_NUMBER_VALUE(obj);

  if(longVal < 0) {
      return SWIG_OverflowError;
  }

  if(val) *val = longVal;

  return SWIG_OK;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_char (SWIGV8_VALUE obj, unsigned char *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UCHAR_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned char >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE
SWIGV8_VALUE SWIG_From_long  (long value)
{
  return SWIGV8_NUMBER_NEW(value);
}


SWIGINTERNINLINE
SWIGV8_VALUE SWIG_From_unsigned_SS_long  (unsigned long value)
{
  return value <= UINT32_MAX ? (SWIGV8_VALUE)SWIGV8_INTEGER_NEW_UNS(value) : (SWIGV8_VALUE)SWIGV8_NUMBER_NEW(static_cast<double>(value));
}


#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
#  define SWIG_LONG_LONG_AVAILABLE
#endif


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE
SWIGV8_VALUE SWIG_From_long_SS_long  (long long value)
{
  return SWIGV8_NUMBER_NEW(value);
}
#endif


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE
SWIGV8_VALUE SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
{
  return value <= UINT32_MAX ? (SWIGV8_VALUE)SWIGV8_INTEGER_NEW_UNS(value) : (SWIGV8_VALUE)SWIGV8_NUMBER_NEW(static_cast<double>(value));
}
#endif


SWIGINTERNINLINE SWIGV8_VALUE
SWIG_From_size_t  (size_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(size_t) <= sizeof(unsigned long long) */
    return SWIG_From_unsigned_SS_long_SS_long  (static_cast< unsigned long long >(value));
  }
#endif
}


SWIGINTERN
int SWIG_AsVal_long (SWIGV8_VALUE obj, long* val)
{
  if (!obj->IsNumber()) {
    return SWIG_TypeError;
  }
  if(val) *val = (long) SWIGV8_INTEGER_VALUE(obj);

  return SWIG_OK;
}


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN
int SWIG_AsVal_unsigned_SS_long_SS_long (SWIGV8_VALUE obj, unsigned long long *val)
{
  if(!obj->IsNumber()) {
    return SWIG_TypeError;
  }

  long long longVal = (long long) SWIGV8_NUMBER_VALUE(obj);

  if(longVal < 0) {
      return SWIG_OverflowError;
  }

  if(val) *val = longVal;

  return SWIG_OK;
}
#endif


SWIGINTERNINLINE int
SWIG_AsVal_size_t (SWIGV8_VALUE obj, size_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
    unsigned long long v;
    res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
  }
#endif
  return res;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_int (SWIGV8_VALUE obj, unsigned int *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UINT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned int >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE SWIGV8_VALUE
SWIG_From_unsigned_SS_int  (unsigned int value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}

SWIGINTERN void _xmlElement_type_set(_xmlElement *self,xmlElementType type){          if (self != NULL) {              self->type = (xmlElementType) type;          }      }
SWIGINTERN void _xmlElement_name_set(_xmlElement *self,xmlChar const *name){          if (self != NULL) {              if (self->name != NULL) {                  xmlFree((void*)self->name);              }                           self->name = xmlStrdup((const xmlChar *) name);          }      }
SWIGINTERN void _xmlElement_children_set(_xmlElement *self,_xmlNode *children){          if (self != NULL) {              self->children = (_xmlNode *) children;          }      }
SWIGINTERN void _xmlElement_last_set(_xmlElement *self,_xmlNode *last){          if (self != NULL) {              self->last = (_xmlNode *) last;          }      }
SWIGINTERN void _xmlElement_parent_set(_xmlElement *self,_xmlDtd *parent){          if (self != NULL) {              self->parent = (_xmlDtd *) parent;          }      }
SWIGINTERN void _xmlElement_next_set(_xmlElement *self,_xmlNode *next){          if (self != NULL) {              self->next = (_xmlNode *) next;          }      }
SWIGINTERN void _xmlElement_prev_set(_xmlElement *self,_xmlNode *prev){          if (self != NULL) {              self->prev = (_xmlNode *) prev;          }      }
SWIGINTERN void _xmlElement_doc_set(_xmlElement *self,_xmlDoc *doc){          if (self != NULL) {              self->doc = (_xmlDoc *) doc;          }      }
SWIGINTERN void _xmlElement_etype_set(_xmlElement *self,xmlElementTypeVal etype){          if (self != NULL) {              self->etype = (xmlElementTypeVal) etype;          }      }
SWIGINTERN void _xmlElement_content_set(_xmlElement *self,xmlElementContentPtr content){          if (self != NULL) {              self->content = (xmlElementContentPtr) content;          }      }
SWIGINTERN void _xmlElement_attributes_set(_xmlElement *self,xmlAttributePtr attributes){          if (self != NULL) {              self->attributes = (xmlAttributePtr) attributes;          }      }
SWIGINTERN void _xmlElement_prefix_set(_xmlElement *self,xmlChar const *prefix){          if (self != NULL) {              if (self->prefix != NULL) {                  xmlFree((void*)self->prefix);              }                           self->prefix = xmlStrdup((const xmlChar *) prefix);          }      }
SWIGINTERN void _xmlElement_contModel_set(_xmlElement *self,xmlRegexpPtr contModel){          if (self != NULL) {              self->contModel = (xmlRegexpPtr) contModel;          }      }
SWIGINTERN void _xmlNs_next_set(_xmlNs *self,_xmlNs *next){          if (self != NULL) {              self->next = (_xmlNs *) next;          }      }
SWIGINTERN void _xmlNs_type_set(_xmlNs *self,xmlNsType type){          if (self != NULL) {              self->type = (xmlNsType) type;          }      }
SWIGINTERN void _xmlNs_href_set(_xmlNs *self,xmlChar const *href){          if (self != NULL) {              if (self->href != NULL) {                  xmlFree((void*)self->href);              }                           self->href = xmlStrdup((const xmlChar *) href);          }      }
SWIGINTERN void _xmlNs_prefix_set(_xmlNs *self,xmlChar const *prefix){          if (self != NULL) {              if (self->prefix != NULL) {                  xmlFree((void*)self->prefix);              }                           self->prefix = xmlStrdup((const xmlChar *) prefix);          }      }
SWIGINTERN void _xmlNs_context_set(_xmlNs *self,_xmlDoc *context){          if (self != NULL) {              self->context = (_xmlDoc *) context;          }      }
SWIGINTERN void _xmlDtd_type_set(_xmlDtd *self,xmlElementType type){          if (self != NULL) {              self->type = (xmlElementType) type;          }      }
SWIGINTERN void _xmlDtd_name_set(_xmlDtd *self,xmlChar const *name){          if (self != NULL) {              if (self->name != NULL) {                  xmlFree((void*)self->name);              }                           self->name = xmlStrdup((const xmlChar *) name);          }      }
SWIGINTERN void _xmlDtd_children_set(_xmlDtd *self,_xmlNode *children){          if (self != NULL) {              self->children = (_xmlNode *) children;          }      }
SWIGINTERN void _xmlDtd_last_set(_xmlDtd *self,_xmlNode *last){          if (self != NULL) {              self->last = (_xmlNode *) last;          }      }
SWIGINTERN void _xmlDtd_parent_set(_xmlDtd *self,_xmlDoc *parent){          if (self != NULL) {              self->parent = (_xmlDoc *) parent;          }      }
SWIGINTERN void _xmlDtd_next_set(_xmlDtd *self,_xmlNode *next){          if (self != NULL) {              self->next = (_xmlNode *) next;          }      }
SWIGINTERN void _xmlDtd_prev_set(_xmlDtd *self,_xmlNode *prev){          if (self != NULL) {              self->prev = (_xmlNode *) prev;          }      }
SWIGINTERN void _xmlDtd_doc_set(_xmlDtd *self,_xmlDoc *doc){          if (self != NULL) {              self->doc = (_xmlDoc *) doc;          }      }
SWIGINTERN void _xmlDtd_notations_set(_xmlDtd *self,void *notations){          if (self != NULL) {              self->notations = (void *) notations;          }      }
SWIGINTERN void _xmlDtd_elements_set(_xmlDtd *self,void *elements){          if (self != NULL) {              self->elements = (void *) elements;          }      }
SWIGINTERN void _xmlDtd_attributes_set(_xmlDtd *self,void *attributes){          if (self != NULL) {              self->attributes = (void *) attributes;          }      }
SWIGINTERN void _xmlDtd_entities_set(_xmlDtd *self,void *entities){          if (self != NULL) {              self->entities = (void *) entities;          }      }
SWIGINTERN void _xmlDtd_ExternalID_set(_xmlDtd *self,xmlChar const *ExternalID){          if (self != NULL) {              if (self->ExternalID != NULL) {                  xmlFree((void*)self->ExternalID);              }                           self->ExternalID = xmlStrdup((const xmlChar *) ExternalID);          }      }
SWIGINTERN void _xmlDtd_SystemID_set(_xmlDtd *self,xmlChar const *SystemID){          if (self != NULL) {              if (self->SystemID != NULL) {                  xmlFree((void*)self->SystemID);              }                           self->SystemID = xmlStrdup((const xmlChar *) SystemID);          }      }
SWIGINTERN void _xmlDtd_pentities_set(_xmlDtd *self,void *pentities){          if (self != NULL) {              self->pentities = (void *) pentities;          }      }
SWIGINTERN void _xmlAttr_type_set(_xmlAttr *self,xmlElementType type){          if (self != NULL) {              self->type = (xmlElementType) type;          }      }
SWIGINTERN void _xmlAttr_name_set(_xmlAttr *self,xmlChar const *name){          if (self != NULL) {              if (self->name != NULL) {                  xmlFree((void*)self->name);              }                           self->name = xmlStrdup((const xmlChar *) name);          }      }
SWIGINTERN void _xmlAttr_children_set(_xmlAttr *self,_xmlNode *children){          if (self != NULL) {              self->children = (_xmlNode *) children;          }      }
SWIGINTERN void _xmlAttr_last_set(_xmlAttr *self,_xmlNode *last){          if (self != NULL) {              self->last = (_xmlNode *) last;          }      }
SWIGINTERN void _xmlAttr_parent_set(_xmlAttr *self,_xmlNode *parent){          if (self != NULL) {              self->parent = (_xmlNode *) parent;          }      }
SWIGINTERN void _xmlAttr_next_set(_xmlAttr *self,_xmlAttr *next){          if (self != NULL) {              self->next = (_xmlAttr *) next;          }      }
SWIGINTERN void _xmlAttr_prev_set(_xmlAttr *self,_xmlAttr *prev){          if (self != NULL) {              self->prev = (_xmlAttr *) prev;          }      }
SWIGINTERN void _xmlAttr_doc_set(_xmlAttr *self,_xmlDoc *doc){          if (self != NULL) {              self->doc = (_xmlDoc *) doc;          }      }
SWIGINTERN void _xmlAttr_ns_set(_xmlAttr *self,xmlNs *ns){          if (self != NULL) {              self->ns = (xmlNs *) ns;          }      }
SWIGINTERN void _xmlAttr_atype_set(_xmlAttr *self,xmlAttributeType atype){          if (self != NULL) {              self->atype = (xmlAttributeType) atype;          }      }
SWIGINTERN void _xmlAttr_psvi_set(_xmlAttr *self,void *psvi){          if (self != NULL) {              self->psvi = (void *) psvi;          }      }
SWIGINTERN void _xmlNode_type_set(_xmlNode *self,xmlElementType type){          if (self != NULL) {              self->type = (xmlElementType) type;          }      }
SWIGINTERN void _xmlNode_name_set(_xmlNode *self,xmlChar const *name){          if (self != NULL) {              if (self->name != NULL) {                  xmlFree((void*)self->name);              }                           self->name = xmlStrdup((const xmlChar *) name);          }      }
SWIGINTERN void _xmlNode_children_set(_xmlNode *self,_xmlNode *children){          if (self != NULL) {              self->children = (_xmlNode *) children;          }      }
SWIGINTERN void _xmlNode_last_set(_xmlNode *self,_xmlNode *last){          if (self != NULL) {              self->last = (_xmlNode *) last;          }      }
SWIGINTERN void _xmlNode_parent_set(_xmlNode *self,_xmlNode *parent){          if (self != NULL) {              self->parent = (_xmlNode *) parent;          }      }
SWIGINTERN void _xmlNode_next_set(_xmlNode *self,_xmlNode *next){          if (self != NULL) {              self->next = (_xmlNode *) next;          }      }
SWIGINTERN void _xmlNode_prev_set(_xmlNode *self,_xmlNode *prev){          if (self != NULL) {              self->prev = (_xmlNode *) prev;          }      }
SWIGINTERN void _xmlNode_doc_set(_xmlNode *self,_xmlDoc *doc){          if (self != NULL) {              self->doc = (_xmlDoc *) doc;          }      }
SWIGINTERN void _xmlNode_ns_set(_xmlNode *self,xmlNs *ns){          if (self != NULL) {              xmlSetNs(self, (xmlNs *) ns);          }      }
SWIGINTERN void _xmlNode_content_set(_xmlNode *self,xmlChar *content){          if (self != NULL) {              if (self->content != NULL) {                  xmlFree((void*)self->content);              }                           self->content = xmlStrdup((xmlChar *) content);          }      }
SWIGINTERN void _xmlNode_properties_set(_xmlNode *self,_xmlAttr *properties){          if (self != NULL) {              self->properties = (_xmlAttr *) properties;          }      }
SWIGINTERN void _xmlNode_nsDef_set(_xmlNode *self,xmlNs *nsDef){          if (self != NULL) {              self->nsDef = (xmlNs *) nsDef;          }      }
SWIGINTERN void _xmlNode_psvi_set(_xmlNode *self,void *psvi){          if (self != NULL) {              self->psvi = (void *) psvi;          }      }

SWIGINTERN int
SWIG_AsVal_unsigned_SS_short (SWIGV8_VALUE obj, unsigned short *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > USHRT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned short >(v);
    }
  }  
  return res;
}

SWIGINTERN void _xmlNode_line_set(_xmlNode *self,unsigned short line){          if (self != NULL) {              self->line = (unsigned short) line;          }      }

SWIGINTERNINLINE SWIGV8_VALUE
SWIG_From_unsigned_SS_short  (unsigned short value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}

SWIGINTERN void _xmlNode_extra_set(_xmlNode *self,unsigned short extra){          if (self != NULL) {              self->extra = (unsigned short) extra;          }      }
SWIGINTERN void _xmlDoc_type_set(_xmlDoc *self,xmlElementType type){          if (self != NULL) {              self->type = (xmlElementType) type;          }      }
SWIGINTERN void _xmlDoc_name_set(_xmlDoc *self,char *name){          if (self != NULL) {              self->name = (char *) name;          }      }
SWIGINTERN void _xmlDoc_children_set(_xmlDoc *self,_xmlNode *children){          if (self != NULL) {              self->children = (_xmlNode *) children;          }      }
SWIGINTERN void _xmlDoc_last_set(_xmlDoc *self,_xmlNode *last){          if (self != NULL) {              self->last = (_xmlNode *) last;          }      }
SWIGINTERN void _xmlDoc_parent_set(_xmlDoc *self,_xmlNode *parent){          if (self != NULL) {              self->parent = (_xmlNode *) parent;          }      }
SWIGINTERN void _xmlDoc_next_set(_xmlDoc *self,_xmlNode *next){          if (self != NULL) {              self->next = (_xmlNode *) next;          }      }
SWIGINTERN void _xmlDoc_prev_set(_xmlDoc *self,_xmlNode *prev){          if (self != NULL) {              self->prev = (_xmlNode *) prev;          }      }
SWIGINTERN void _xmlDoc_doc_set(_xmlDoc *self,_xmlDoc *doc){          if (self != NULL) {              self->doc = (_xmlDoc *) doc;          }      }
SWIGINTERN void _xmlDoc_compression_set(_xmlDoc *self,int compression){          if (self != NULL) {              self->compression = (int) compression;          }      }
SWIGINTERN void _xmlDoc_standalone_set(_xmlDoc *self,int standalone){          if (self != NULL) {              self->standalone = (int) standalone;          }      }
SWIGINTERN void _xmlDoc_intSubset_set(_xmlDoc *self,_xmlDtd *intSubset){          if (self != NULL) {              self->intSubset = (_xmlDtd *) intSubset;          }      }
SWIGINTERN void _xmlDoc_extSubset_set(_xmlDoc *self,_xmlDtd *extSubset){          if (self != NULL) {              self->extSubset = (_xmlDtd *) extSubset;          }      }
SWIGINTERN void _xmlDoc_oldNs_set(_xmlDoc *self,_xmlNs *oldNs){          if (self != NULL) {              self->oldNs = (_xmlNs *) oldNs;          }      }
SWIGINTERN void _xmlDoc_version_set(_xmlDoc *self,xmlChar const *version){          if (self != NULL) {              if (self->version != NULL) {                  xmlFree((void*)self->version);              }                           self->version = xmlStrdup((const xmlChar *) version);          }      }
SWIGINTERN void _xmlDoc_encoding_set(_xmlDoc *self,xmlChar const *encoding){          if (self != NULL) {              if (self->encoding != NULL) {                  xmlFree((void*)self->encoding);              }                           self->encoding = xmlStrdup((const xmlChar *) encoding);          }      }
SWIGINTERN void _xmlDoc_ids_set(_xmlDoc *self,void *ids){          if (self != NULL) {              self->ids = (void *) ids;          }      }
SWIGINTERN void _xmlDoc_refs_set(_xmlDoc *self,void *refs){          if (self != NULL) {              self->refs = (void *) refs;          }      }
SWIGINTERN void _xmlDoc_URL_set(_xmlDoc *self,xmlChar const *URL){          if (self != NULL) {              if (self->URL != NULL) {                  xmlFree((void*)self->URL);              }                           self->URL = xmlStrdup((const xmlChar *) URL);          }      }
SWIGINTERN void _xmlDoc_charset_set(_xmlDoc *self,int charset){          if (self != NULL) {              self->charset = (int) charset;          }      }
SWIGINTERN void _xmlDoc_dict_set(_xmlDoc *self,_xmlDict *dict){          if (self != NULL) {              self->dict = (_xmlDict *) dict;          }      }
SWIGINTERN void _xmlDoc_psvi_set(_xmlDoc *self,void *psvi){          if (self != NULL) {              self->psvi = (void *) psvi;          }      }
SWIGINTERN void _xmlDoc_parseFlags_set(_xmlDoc *self,int parseFlags){          if (self != NULL) {              self->parseFlags = (int) parseFlags;          }      }
SWIGINTERN void _xmlDoc_properties_set(_xmlDoc *self,int properties){          if (self != NULL) {              self->properties = (int) properties;          }      }
SWIGINTERN void _xmlEntity_type_set(_xmlEntity *self,xmlElementType type){          if (self != NULL) {              self->type = (xmlElementType) type;          }      }
SWIGINTERN void _xmlEntity_name_set(_xmlEntity *self,xmlChar const *name){          if (self != NULL) {              if (self->name != NULL) {                  xmlFree((void*)self->name);              }                           self->name = xmlStrdup((const xmlChar *) name);          }      }
SWIGINTERN void _xmlEntity_children_set(_xmlEntity *self,_xmlNode *children){          if (self != NULL) {              self->children = (_xmlNode *) children;          }      }
SWIGINTERN void _xmlEntity_last_set(_xmlEntity *self,_xmlNode *last){          if (self != NULL) {              self->last = (_xmlNode *) last;          }      }
SWIGINTERN void _xmlEntity_parent_set(_xmlEntity *self,_xmlDtd *parent){          if (self != NULL) {              self->parent = (_xmlDtd *) parent;          }      }
SWIGINTERN void _xmlEntity_next_set(_xmlEntity *self,_xmlNode *next){          if (self != NULL) {              self->next = (_xmlNode *) next;          }      }
SWIGINTERN void _xmlEntity_prev_set(_xmlEntity *self,_xmlNode *prev){          if (self != NULL) {              self->prev = (_xmlNode *) prev;          }      }
SWIGINTERN void _xmlEntity_doc_set(_xmlEntity *self,_xmlDoc *doc){          if (self != NULL) {              self->doc = (_xmlDoc *) doc;          }      }
SWIGINTERN void _xmlEntity_orig_set(_xmlEntity *self,xmlChar *orig){          if (self != NULL) {              if (self->orig != NULL) {                  xmlFree((void*)self->orig);              }                           self->orig = xmlStrdup((xmlChar *) orig);          }      }
SWIGINTERN void _xmlEntity_content_set(_xmlEntity *self,xmlChar *content){          if (self != NULL) {              if (self->content != NULL) {                  xmlFree((void*)self->content);              }                           self->content = xmlStrdup((xmlChar *) content);          }      }
SWIGINTERN void _xmlEntity_length_set(_xmlEntity *self,int length){          if (self != NULL) {              self->length = (int) length;          }      }
SWIGINTERN void _xmlEntity_etype_set(_xmlEntity *self,xmlEntityType etype){          if (self != NULL) {              self->etype = (xmlEntityType) etype;          }      }
SWIGINTERN void _xmlEntity_ExternalID_set(_xmlEntity *self,xmlChar const *ExternalID){          if (self != NULL) {              if (self->ExternalID != NULL) {                  xmlFree((void*)self->ExternalID);              }                           self->ExternalID = xmlStrdup((const xmlChar *) ExternalID);          }      }
SWIGINTERN void _xmlEntity_SystemID_set(_xmlEntity *self,xmlChar const *SystemID){          if (self != NULL) {              if (self->SystemID != NULL) {                  xmlFree((void*)self->SystemID);              }                           self->SystemID = xmlStrdup((const xmlChar *) SystemID);          }      }
SWIGINTERN void _xmlEntity_nexte_set(_xmlEntity *self,_xmlEntity *nexte){          if (self != NULL) {              self->nexte = (_xmlEntity *) nexte;          }      }
SWIGINTERN void _xmlEntity_URI_set(_xmlEntity *self,xmlChar const *URI){          if (self != NULL) {              if (self->URI != NULL) {                  xmlFree((void*)self->URI);              }                           self->URI = xmlStrdup((const xmlChar *) URI);          }      }
SWIGINTERN void _xmlEntity_owner_set(_xmlEntity *self,int owner){          if (self != NULL) {              self->owner = (int) owner;          }      }
SWIGINTERN void _xmlEntity_checked_set(_xmlEntity *self,int checked){          if (self != NULL) {              self->checked = (int) checked;          }      }

SWIGINTERN
SWIGV8_VALUE SWIG_From_double   (double val)
{
  return SWIGV8_NUMBER_NEW(val);
}


SWIGINTERN int
SWIG_AsCharArray(SWIGV8_VALUE 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)) {
    /* special case of single char conversion when we don't need space for NUL */
    if (size == 1 && csize == 2 && cptr && !cptr[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) {
	delete[] cptr;
	res = SWIG_DelNewMask(res);
      }      
      return res;
    }
    if (alloc == SWIG_NEWOBJ) delete[] cptr;
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_char (SWIGV8_VALUE obj, char *val)
{    
  int res = SWIG_AsCharArray(obj, val, 1);
  if (!SWIG_IsOK(res)) {
    long v;
    res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
    if (SWIG_IsOK(res)) {
      if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
	if (val) *val = static_cast< char >(v);
      } else {
	res = SWIG_OverflowError;
      }
    }
  }
  return res;
}


SWIGINTERNINLINE SWIGV8_VALUE
SWIG_From_char  (char c) 
{ 
  return SWIG_FromCharPtrAndSize(&c,1);
}


SWIGINTERNINLINE SWIGV8_VALUE
SWIG_From_unsigned_SS_char  (unsigned char value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}


#define SWIGV8_INIT libxml2_initialize


SWIGV8_ClientData _exports__xmlBuffer_clientData;
SWIGV8_ClientData _exports__xmlNotation_clientData;
SWIGV8_ClientData _exports__xmlEnumeration_clientData;
SWIGV8_ClientData _exports__xmlAttribute_clientData;
SWIGV8_ClientData _exports__xmlElementContent_clientData;
SWIGV8_ClientData _exports__xmlElement_clientData;
SWIGV8_ClientData _exports__xmlNs_clientData;
SWIGV8_ClientData _exports__xmlDtd_clientData;
SWIGV8_ClientData _exports__xmlAttr_clientData;
SWIGV8_ClientData _exports__xmlID_clientData;
SWIGV8_ClientData _exports__xmlRef_clientData;
SWIGV8_ClientData _exports__xmlNode_clientData;
SWIGV8_ClientData _exports__xmlDoc_clientData;
SWIGV8_ClientData _exports__xmlDOMWrapCtxt_clientData;
SWIGV8_ClientData _exports__xmlError_clientData;
SWIGV8_ClientData _exports__xmlValidCtxt_clientData;
SWIGV8_ClientData _exports__xmlEntity_clientData;
SWIGV8_ClientData _exports__xmlCharEncodingHandler_clientData;
SWIGV8_ClientData _exports__xmlParserInputBuffer_clientData;
SWIGV8_ClientData _exports__xmlOutputBuffer_clientData;
SWIGV8_ClientData _exports__xmlParserInput_clientData;
SWIGV8_ClientData _exports__xmlParserNodeInfo_clientData;
SWIGV8_ClientData _exports__xmlParserNodeInfoSeq_clientData;
SWIGV8_ClientData _exports__xmlParserCtxt_clientData;
SWIGV8_ClientData _exports__xmlSAXLocator_clientData;
SWIGV8_ClientData _exports__xmlSAXHandler_clientData;
SWIGV8_ClientData _exports__xmlSAXHandlerV1_clientData;
SWIGV8_ClientData _exports__xmlNodeSet_clientData;
SWIGV8_ClientData _exports__xmlXPathObject_clientData;
SWIGV8_ClientData _exports__xmlXPathType_clientData;
SWIGV8_ClientData _exports__xmlXPathVariable_clientData;
SWIGV8_ClientData _exports__xmlXPathFunct_clientData;
SWIGV8_ClientData _exports__xmlXPathAxis_clientData;
SWIGV8_ClientData _exports__xmlXPathContext_clientData;
SWIGV8_ClientData _exports__xmlXPathParserContext_clientData;
SWIGV8_ClientData _exports__xmlChSRange_clientData;
SWIGV8_ClientData _exports__xmlChLRange_clientData;
SWIGV8_ClientData _exports__xmlChRangeGroup_clientData;
SWIGV8_ClientData _exports__htmlElemDesc_clientData;
SWIGV8_ClientData _exports__htmlEntityDesc_clientData;
SWIGV8_ClientData _exports__xmlURI_clientData;
SWIGV8_ClientData _exports__xlinkHandler_clientData;
SWIGV8_ClientData _exports__xmlSchemaAnnot_clientData;
SWIGV8_ClientData _exports__xmlSchemaAttribute_clientData;
SWIGV8_ClientData _exports__xmlSchemaAttributeLink_clientData;
SWIGV8_ClientData _exports__xmlSchemaWildcardNs_clientData;
SWIGV8_ClientData _exports__xmlSchemaWildcard_clientData;
SWIGV8_ClientData _exports__xmlSchemaAttributeGroup_clientData;
SWIGV8_ClientData _exports__xmlSchemaTypeLink_clientData;
SWIGV8_ClientData _exports__xmlSchemaFacetLink_clientData;
SWIGV8_ClientData _exports__xmlSchemaType_clientData;
SWIGV8_ClientData _exports__xmlSchemaElement_clientData;
SWIGV8_ClientData _exports__xmlSchemaFacet_clientData;
SWIGV8_ClientData _exports__xmlSchemaNotation_clientData;
SWIGV8_ClientData _exports__xmlSchema_clientData;


static SwigV8ReturnValue _wrap_setDebugEnable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_setDebugEnable.");
  
  setDebugEnable();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_setDebugDisable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_setDebugDisable.");
  
  setDebugDisable();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_libxmljs_debug_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  
  ecode1 = SWIG_AsVal_int(value, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "libxmljs_debug_set" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);libxmljs_debug = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_libxmljs_debug_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  result = (int)libxmljs_debug;
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_getMemUsed(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_getMemUsed.");
  
  result = (int)getMemUsed();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_getNodeCount(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_getNodeCount.");
  
  result = (int)getNodeCount();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_getWrapCount(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_getWrapCount.");
  
  result = (int)getWrapCount();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDocHasRootElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDoc *arg1 = (xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  bool result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDocHasRootElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlDocHasRootElement', argument 1 of type 'xmlDoc const *'"); 
  }
  arg1 = (xmlDoc *) arg10;result = (bool)xmlDocHasRootElement((_xmlDoc const *)arg1);
  jsresult = SWIG_From_bool(static_cast< bool >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUnlinkNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUnlinkNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlUnlinkNode', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);_xmlUnlinkNode(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


    // RAII sentinel to collect errors in synchroneous operations
    class LIBXMLJS_API XmlSyntaxErrorsSync {

    public:

        XmlSyntaxErrorsSync();
        ~XmlSyntaxErrorsSync();

        // create a v8 object for the syntax eror
        static v8::Local<v8::Value> BuildSyntaxError(xmlError* error);

        v8::Local<v8::Array> ToArray() {
            return errors;
        }

    private:

        v8::Local<v8::Array> errors;

        // called from xml library to report errors,
        // will make a copy and store it in vector
        static void ErrorFunc(void* errs, xmlError* error);

    };

    class LIBXMLJS_API XmlSyntaxErrorsStore {

    public:

        ~XmlSyntaxErrorsStore();

        v8::Local<v8::Array> ToArray();

        static xmlError* CloneError(xmlError* error);

        static void FreeError(xmlError* error);

    private:

        // store errors in a non-v8 data structure, important for async operation
        std::vector<xmlError*> errors;

        // called from xml library to report errors,
        // will make a copy and store it in vector
        static void ErrorFunc(void* errs, xmlError* error);

        friend class XmlSyntaxErrorsAsync;

    };

    // RAII sentinel to collect errors in asynchroneous operation
    class LIBXMLJS_API XmlSyntaxErrorsAsync {

    public:

        XmlSyntaxErrorsAsync(XmlSyntaxErrorsStore& store) {
            xmlResetLastError();
            xmlSetStructuredErrorFunc(&store, XmlSyntaxErrorsStore::ErrorFunc);
        }

        ~XmlSyntaxErrorsAsync() {
            xmlSetStructuredErrorFunc(NULL, NULL);
        }

    };

    XmlSyntaxErrorsSync::XmlSyntaxErrorsSync() {
        errors = Nan::New<v8::Array>();
        xmlResetLastError();
        xmlSetStructuredErrorFunc(this, ErrorFunc);
    }

    XmlSyntaxErrorsSync::~XmlSyntaxErrorsSync() {
        xmlSetStructuredErrorFunc(NULL, NULL);
    }

    v8::Local<v8::Value>
    XmlSyntaxErrorsSync::BuildSyntaxError(xmlError* error) {
        Nan::EscapableHandleScope scope;

        v8::Local<v8::Value> err = v8::Exception::Error(
                Nan::New<v8::String>(error->message).ToLocalChecked());
        v8::Local<v8::Object> out = v8::Local<v8::Object>::Cast(err);

        set_numeric_field(out, "domain", error->domain);
        set_numeric_field(out, "code", error->code);
        set_string_field(out, "message", error->message);
        set_numeric_field(out, "level", error->level);
        set_numeric_field(out, "column", error->int2);
        set_string_field(out, "file", error->file);
        set_numeric_field(out, "line", error->line);
        set_string_field(out, "str1", error->str1);
        set_string_field(out, "str2", error->str2);
        set_string_field(out, "str3", error->str3);

        // only add if we have something interesting
        if (error->int1) {
            set_numeric_field(out, "int1", error->int1);
        }
        return scope.Escape(err);
    }

    void
    XmlSyntaxErrorsSync::ErrorFunc(void* errs, xmlError* error) {
        Nan::HandleScope scope;
        XmlSyntaxErrorsSync* self = ((XmlSyntaxErrorsSync*) errs);
        SWIGV8_AppendOutput(self->errors, BuildSyntaxError(error));
    }

    XmlSyntaxErrorsStore::~XmlSyntaxErrorsStore() {
        typedef std::vector<xmlError*>::reverse_iterator iter;
        for (iter i = errors.rbegin(), e = errors.rend(); i != e; ++i)
            FreeError(*i);
    }

    v8::Local<v8::Array>
    XmlSyntaxErrorsStore::ToArray() {
        Nan::EscapableHandleScope scope;
        v8::Local<v8::Array> array = Nan::New<v8::Array>(errors.size());
        for (uint32_t i = 0; i != errors.size(); ++i)
            SWIGV8_AppendOutput(array, XmlSyntaxErrorsSync::BuildSyntaxError(errors[i]));
        return scope.Escape(array);
    }

    void
    XmlSyntaxErrorsStore::ErrorFunc(void* errs, xmlError* error) {
        XmlSyntaxErrorsStore* self = ((XmlSyntaxErrorsStore*) errs);
        xmlError* clone = CloneError(error);
        if (clone)
            self->errors.push_back(clone);
    }

    xmlError*
    XmlSyntaxErrorsStore::CloneError(xmlError* err1) {
        if (!err1) return NULL;
        xmlError* err2 = ((xmlError*) xmlMalloc(sizeof(xmlError)));
        if (!err2) return NULL;
        *err2 = *err1;
        if(err1->message) err2->message = xmlMemStrdup(err1->message);
        if(err1->file   ) err2->file    = xmlMemStrdup(err1->file   );
        if(err1->str1   ) err2->str1    = xmlMemStrdup(err1->str1   );
        if(err1->str2   ) err2->str2    = xmlMemStrdup(err1->str2   );
        if(err1->str3   ) err2->str3    = xmlMemStrdup(err1->str3   );
        return err2;
    }

    void
    XmlSyntaxErrorsStore::FreeError(xmlError* err) {
        if (err->message) xmlFree(err->message);
        if (err->file) xmlFree(err->file);
        if (err->str1) xmlFree(err->str1);
        if (err->str2) xmlFree(err->str2);
        if (err->str3) xmlFree(err->str3);
        xmlFree(err);
    }

    class FromXmlWorker : public Nan::AsyncWorker {
    public:
        int type;
        char *buffer;
        size_t length;
        char* url;
        char* encoding;
        int flags;
        xmlDocPtr doc;
        WorkerParent parent;
        FromXmlWorker(Nan::Callback* callback,
                    int type,
                    SWIGV8_VALUE buffer,
                    int length,
                    SWIGV8_VALUE url,
                    SWIGV8_VALUE encoding,
                    int flags);
        void Execute();
        void WorkComplete();
        XmlSyntaxErrorsStore errors;
        xmlError* lastError;
    };

    FromXmlWorker::FromXmlWorker(Nan::Callback* callback,
                    int type,
                    SWIGV8_VALUE buffer,
                    int length,
                    SWIGV8_VALUE url,
                    SWIGV8_VALUE encoding,
                    int flags)
        : Nan::AsyncWorker(callback, "nan:FromXmlWorker"), lastError(NULL) {
        Nan::HandleScope scope;

        this->type = type;

        if (buffer->IsString()) {
            SWIG_AsCharPtrAndSize(buffer, &this->buffer, NULL, NULL);
        } else {
            this->buffer = node::Buffer::Data(buffer);
        }

        this->length = length;
        
        SWIG_AsCharPtrAndSize(url, &this->url, NULL, NULL);
        SWIG_AsCharPtrAndSize(encoding, &this->encoding, NULL, NULL);

        this->flags = flags;

        // this->SaveToPersistent("buf", buf);
        // this->SaveToPersistent("opt", opt);
    }

    void FromXmlWorker::Execute() {
        WorkerSentinel workerSentinel(parent);
        XmlSyntaxErrorsAsync errorsSentinel(errors);

        // printf("Async Execute type: %i, buffer: %s, length: %i, url: %s, encoding: %s, flags: %i\n", this->type, this->buffer, this->length, this->url, this->encoding, this->flags);

        if (this->type < 1) {
            this->doc = xmlReadMemory(this->buffer, this->length, this->url, this->encoding, this->flags);
        } else {
            this->doc = htmlReadMemory(this->buffer, this->length, this->url, this->encoding, this->flags);
        }

        if (!doc)
            lastError = XmlSyntaxErrorsStore::CloneError(xmlGetLastError());
    }

    void FromXmlWorker::WorkComplete() {
        Nan::HandleScope scope;
        if (!doc) {
            v8::Local<v8::Value> argv[2];
            if (lastError) {
                v8::Local<v8::Value> error =
                    XmlSyntaxErrorsSync::BuildSyntaxError(lastError);
                XmlSyntaxErrorsStore::FreeError(lastError);
                argv[0] = error;
            } else {
                argv[0] = v8::Exception::Error(Nan::New<v8::String>
                                            ("Could not parse XML string")
                                            .ToLocalChecked());
            }
            argv[1] = Nan::Null();
            Nan::Call(*callback, Nan::GetCurrentContext()->Global(), 2, argv);
        } else {
            auto doc_handle = createWrap((xmlNode*) doc, SWIGTYPE_p__xmlDoc);
            auto doc_object = SWIGV8_TO_OBJECT(doc_handle);

            Nan::Set(doc_object,
                    Nan::New<v8::String>("errors").ToLocalChecked(),
                    errors.ToArray());
            v8::Local<v8::Value> argv[2] = {
                Nan::Null(),
                doc_object
            };
            Nan::Call(*callback, Nan::GetCurrentContext()->Global(), 2, argv);
        }
    }

    NAN_METHOD(fromBufferAsync) {
        Nan::HandleScope scope;

        auto type =     Nan::To<int>(info[0]).FromJust();
        auto buffer =   info[1];
        auto length =   Nan::To<int>(info[2]).FromJust();
        auto url =      info[3];
        auto encoding = info[4];
        auto flags =    Nan::To<int>(info[5]).FromJust();
        Nan::Callback* callback = new Nan::Callback(Nan::To<v8::Function>(info[6]).ToLocalChecked());

        Nan::AsyncQueueWorker(new FromXmlWorker(callback, type, buffer, length, url, encoding, flags));
    }


static SwigV8ReturnValue exports_HAVE_ARPA_INET_H_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_ATTRIBUTE_DESTRUCTOR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_DLFCN_H_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_DLOPEN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_FCNTL_H_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_FTIME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_GETENTROPY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_GETTIMEOFDAY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_LIBREADLINE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_MMAP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_MUNMAP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_NETDB_H_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_NETINET_IN_H_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_POLL_H_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_PTHREAD_H_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_STAT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_STDINT_H_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_SYS_MMAN_H_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_SYS_RANDOM_H_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_SYS_SELECT_H_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_SYS_SOCKET_H_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_SYS_STAT_H_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_SYS_TIMEB_H_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_SYS_TIME_H_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HAVE_UNISTD_H_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_VERSION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_FromCharPtr((const char *)"2.13.2");
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_LIBXML_DOTTED_VERSION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_FromCharPtr((const char *)"2.13.2");
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_LIBXML_VERSION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(21302));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_LIBXML_VERSION_STRING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_FromCharPtr((const char *)"21302");
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_LIBXML_VERSION_EXTRA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_FromCharPtr((const char *)"");
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_LIBXML_MODULE_EXTENSION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_FromCharPtr((const char *)".dylib");
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlCheckVersion(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCheckVersion.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlCheckVersion" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);xmlCheckVersion(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStrdup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStrdup.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStrdup" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlChar *)xmlStrdup((unsigned char const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStrndup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStrndup.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStrndup" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlStrndup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlChar *)xmlStrndup((unsigned char const *)arg1,arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCharStrndup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCharStrndup.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCharStrndup" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlCharStrndup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlChar *)xmlCharStrndup((char const *)arg1,arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  // free(arg1);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCharStrdup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCharStrdup.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCharStrdup" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (xmlChar *)xmlCharStrdup((char const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStrsub(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int arg2 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStrsub.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStrsub" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlStrsub" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlStrsub" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlChar *)xmlStrsub((unsigned char const *)arg1,arg2,arg3);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStrchr(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStrchr.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStrchr" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }ecode2 = SWIG_AsVal_unsigned_SS_char(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlStrchr" "', argument " "2"" of type '" "xmlChar""'");
  } 
  arg2 = static_cast< xmlChar >(val2);result = (xmlChar *)xmlStrchr((unsigned char const *)arg1,arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStrstr(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStrstr.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStrstr" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStrstr" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlStrstr((unsigned char const *)arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStrcasestr(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStrcasestr.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStrcasestr" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStrcasestr" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlStrcasestr((unsigned char const *)arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStrcmp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStrcmp.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStrcmp" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStrcmp" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlStrcmp((unsigned char const *)arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStrncmp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStrncmp.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStrncmp" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStrncmp" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlStrncmp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlStrncmp((unsigned char const *)arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStrcasecmp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStrcasecmp.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStrcasecmp" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStrcasecmp" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlStrcasecmp((unsigned char const *)arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStrncasecmp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStrncasecmp.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStrncasecmp" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStrncasecmp" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlStrncasecmp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlStrncasecmp((unsigned char const *)arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStrEqual(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStrEqual.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStrEqual" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStrEqual" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlStrEqual((unsigned char const *)arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStrQEqual(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStrQEqual.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStrQEqual" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStrQEqual" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlStrQEqual" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (int)xmlStrQEqual((unsigned char const *)arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStrlen(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStrlen.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStrlen" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (int)xmlStrlen((unsigned char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStrcat(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStrcat.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStrcat" "', argument " "1"" of type '" "xmlChar *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStrcat" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlStrcat(arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStrncat(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStrncat.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStrncat" "', argument " "1"" of type '" "xmlChar *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStrncat" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlStrncat" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlChar *)xmlStrncat(arg1,(unsigned char const *)arg2,arg3);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStrncatNew(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStrncatNew.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStrncatNew" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStrncatNew" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlStrncatNew" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlChar *)xmlStrncatNew((unsigned char const *)arg1,(unsigned char const *)arg2,arg3);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStrPrintf(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  void *arg4 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStrPrintf.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStrPrintf" "', argument " "1"" of type '" "xmlChar *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlStrPrintf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlStrPrintf" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }result = (int)xmlStrPrintf(arg1,arg2,(char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  // free(arg3);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetUTF8Char(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned char *arg1 = (unsigned char *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetUTF8Char.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlGetUTF8Char" "', argument " "1"" of type '" "unsigned char const *""'"); 
  }
  arg1 = reinterpret_cast< unsigned char * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlGetUTF8Char" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);result = (int)xmlGetUTF8Char((unsigned char const *)arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCheckUTF8(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned char *arg1 = (unsigned char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCheckUTF8.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCheckUTF8" "', argument " "1"" of type '" "unsigned char const *""'"); 
  }
  arg1 = reinterpret_cast< unsigned char * >(argp1);result = (int)xmlCheckUTF8((unsigned char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUTF8Strsize(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUTF8Strsize.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlUTF8Strsize" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlUTF8Strsize" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlUTF8Strsize((unsigned char const *)arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUTF8Strndup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUTF8Strndup.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlUTF8Strndup" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlUTF8Strndup" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlChar *)xmlUTF8Strndup((unsigned char const *)arg1,arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUTF8Strpos(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUTF8Strpos.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlUTF8Strpos" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlUTF8Strpos" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlChar *)xmlUTF8Strpos((unsigned char const *)arg1,arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUTF8Strloc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUTF8Strloc.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlUTF8Strloc" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlUTF8Strloc" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlUTF8Strloc((unsigned char const *)arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUTF8Strsub(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int arg2 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUTF8Strsub.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlUTF8Strsub" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlUTF8Strsub" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlUTF8Strsub" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlChar *)xmlUTF8Strsub((unsigned char const *)arg1,arg2,arg3);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUTF8Strlen(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUTF8Strlen.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlUTF8Strlen" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (int)xmlUTF8Strlen((unsigned char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUTF8Size(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUTF8Size.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlUTF8Size" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (int)xmlUTF8Size((unsigned char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUTF8Charcmp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUTF8Charcmp.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlUTF8Charcmp" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlUTF8Charcmp" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlUTF8Charcmp((unsigned char const *)arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_xmlMalloc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlMallocFunc arg1 = (xmlMallocFunc) 0 ;
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg1), SWIGTYPE_p_f_size_t__p_void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlMalloc_set" "', argument " "1"" of type '" "xmlMallocFunc""'"); 
      }
    }
  }
  xmlMalloc = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlMalloc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlMallocFunc result;
  
  result = (xmlMallocFunc)xmlMalloc;
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_size_t__p_void);
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap_xmlMallocAtomic_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlMallocFunc arg1 = (xmlMallocFunc) 0 ;
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg1), SWIGTYPE_p_f_size_t__p_void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlMallocAtomic_set" "', argument " "1"" of type '" "xmlMallocFunc""'"); 
      }
    }
  }
  xmlMallocAtomic = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlMallocAtomic_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlMallocFunc result;
  
  result = (xmlMallocFunc)xmlMallocAtomic;
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_size_t__p_void);
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap_xmlRealloc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlReallocFunc arg1 = (xmlReallocFunc) 0 ;
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg1), SWIGTYPE_p_f_p_void_size_t__p_void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRealloc_set" "', argument " "1"" of type '" "xmlReallocFunc""'"); 
      }
    }
  }
  xmlRealloc = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlRealloc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlReallocFunc result;
  
  result = (xmlReallocFunc)xmlRealloc;
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_size_t__p_void);
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap_xmlFree_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlFreeFunc arg1 = (xmlFreeFunc) 0 ;
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg1), SWIGTYPE_p_f_p_void__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlFree_set" "', argument " "1"" of type '" "xmlFreeFunc""'"); 
      }
    }
  }
  xmlFree = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlFree_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlFreeFunc result;
  
  result = (xmlFreeFunc)xmlFree;
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap_xmlMemStrdup_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlStrdupFunc arg1 = (xmlStrdupFunc) 0 ;
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char__p_char);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlMemStrdup_set" "', argument " "1"" of type '" "xmlStrdupFunc""'"); 
      }
    }
  }
  xmlMemStrdup = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlMemStrdup_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlStrdupFunc result;
  
  result = (xmlStrdupFunc)xmlMemStrdup;
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char__p_char);
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlMemSetup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlFreeFunc arg1 = (xmlFreeFunc) 0 ;
  xmlMallocFunc arg2 = (xmlMallocFunc) 0 ;
  xmlReallocFunc arg3 = (xmlReallocFunc) 0 ;
  xmlStrdupFunc arg4 = (xmlStrdupFunc) 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMemSetup.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p_void__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlMemSetup" "', argument " "1"" of type '" "xmlFreeFunc""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_size_t__p_void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlMemSetup" "', argument " "2"" of type '" "xmlMallocFunc""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_size_t__p_void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlMemSetup" "', argument " "3"" of type '" "xmlReallocFunc""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[3], (void**)(&arg4), SWIGTYPE_p_f_p_q_const__char__p_char);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlMemSetup" "', argument " "4"" of type '" "xmlStrdupFunc""'"); 
      }
    }
  }
  result = (int)xmlMemSetup(arg1,arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlMemGet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlFreeFunc *arg1 = (xmlFreeFunc *) 0 ;
  xmlMallocFunc *arg2 = (xmlMallocFunc *) 0 ;
  xmlReallocFunc *arg3 = (xmlReallocFunc *) 0 ;
  xmlStrdupFunc *arg4 = (xmlStrdupFunc *) 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 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMemGet.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_p_f_p_void__void, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlMemGet" "', argument " "1"" of type '" "xmlFreeFunc *""'"); 
  }
  arg1 = reinterpret_cast< xmlFreeFunc * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_f_size_t__p_void, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlMemGet" "', argument " "2"" of type '" "xmlMallocFunc *""'"); 
  }
  arg2 = reinterpret_cast< xmlMallocFunc * >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p_f_p_void_size_t__p_void, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlMemGet" "', argument " "3"" of type '" "xmlReallocFunc *""'"); 
  }
  arg3 = reinterpret_cast< xmlReallocFunc * >(argp3);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_p_f_p_q_const__char__p_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlMemGet" "', argument " "4"" of type '" "xmlStrdupFunc *""'"); 
  }
  arg4 = reinterpret_cast< xmlStrdupFunc * >(argp4);result = (int)xmlMemGet(arg1,arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGcMemSetup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlFreeFunc arg1 = (xmlFreeFunc) 0 ;
  xmlMallocFunc arg2 = (xmlMallocFunc) 0 ;
  xmlMallocFunc arg3 = (xmlMallocFunc) 0 ;
  xmlReallocFunc arg4 = (xmlReallocFunc) 0 ;
  xmlStrdupFunc arg5 = (xmlStrdupFunc) 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGcMemSetup.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p_void__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlGcMemSetup" "', argument " "1"" of type '" "xmlFreeFunc""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_size_t__p_void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlGcMemSetup" "', argument " "2"" of type '" "xmlMallocFunc""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[2], (void**)(&arg3), SWIGTYPE_p_f_size_t__p_void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlGcMemSetup" "', argument " "3"" of type '" "xmlMallocFunc""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[3], (void**)(&arg4), SWIGTYPE_p_f_p_void_size_t__p_void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlGcMemSetup" "', argument " "4"" of type '" "xmlReallocFunc""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[4], (void**)(&arg5), SWIGTYPE_p_f_p_q_const__char__p_char);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlGcMemSetup" "', argument " "5"" of type '" "xmlStrdupFunc""'"); 
      }
    }
  }
  result = (int)xmlGcMemSetup(arg1,arg2,arg3,arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGcMemGet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlFreeFunc *arg1 = (xmlFreeFunc *) 0 ;
  xmlMallocFunc *arg2 = (xmlMallocFunc *) 0 ;
  xmlMallocFunc *arg3 = (xmlMallocFunc *) 0 ;
  xmlReallocFunc *arg4 = (xmlReallocFunc *) 0 ;
  xmlStrdupFunc *arg5 = (xmlStrdupFunc *) 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 result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGcMemGet.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_p_f_p_void__void, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlGcMemGet" "', argument " "1"" of type '" "xmlFreeFunc *""'"); 
  }
  arg1 = reinterpret_cast< xmlFreeFunc * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_f_size_t__p_void, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlGcMemGet" "', argument " "2"" of type '" "xmlMallocFunc *""'"); 
  }
  arg2 = reinterpret_cast< xmlMallocFunc * >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p_f_size_t__p_void, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlGcMemGet" "', argument " "3"" of type '" "xmlMallocFunc *""'"); 
  }
  arg3 = reinterpret_cast< xmlMallocFunc * >(argp3);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_p_f_p_void_size_t__p_void, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlGcMemGet" "', argument " "4"" of type '" "xmlReallocFunc *""'"); 
  }
  arg4 = reinterpret_cast< xmlReallocFunc * >(argp4);res5 = SWIG_ConvertPtr(args[4], &argp5,SWIGTYPE_p_p_f_p_q_const__char__p_char, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlGcMemGet" "', argument " "5"" of type '" "xmlStrdupFunc *""'"); 
  }
  arg5 = reinterpret_cast< xmlStrdupFunc * >(argp5);result = (int)xmlGcMemGet(arg1,arg2,arg3,arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlInitMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlInitMemory.");
  
  result = (int)xmlInitMemory();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCleanupMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCleanupMemory.");
  
  xmlCleanupMemory();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlMemSize(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  size_t result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMemSize.");
  
  arg1 = getSwigCObjectPtr(args[0]);result = xmlMemSize(arg1);
  jsresult = SWIG_From_size_t(static_cast< size_t >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlMemUsed(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMemUsed.");
  
  result = (int)xmlMemUsed();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlMemBlocks(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMemBlocks.");
  
  result = (int)xmlMemBlocks();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlMemDisplay(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMemDisplay.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlMemDisplay" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);xmlMemDisplay(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlMemDisplayLast(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMemDisplayLast.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlMemDisplayLast" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);ecode2 = SWIG_AsVal_long(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlMemDisplayLast" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);xmlMemDisplayLast(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlMemShow(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMemShow.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlMemShow" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlMemShow" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlMemShow(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlMemoryDump(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMemoryDump.");
  
  xmlMemoryDump();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlMemMalloc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMemMalloc.");
  
  ecode1 = SWIG_AsVal_size_t(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlMemMalloc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);result = (void *)xmlMemMalloc(SWIG_STD_MOVE(arg1));
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlMemRealloc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  size_t arg2 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMemRealloc.");
  
  arg1 = getSwigCObjectPtr(args[0]);ecode2 = SWIG_AsVal_size_t(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlMemRealloc" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);result = (void *)xmlMemRealloc(arg1,SWIG_STD_MOVE(arg2));
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlMemFree(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMemFree.");
  
  arg1 = getSwigCObjectPtr(args[0]);xmlMemFree(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlMemoryStrdup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  char *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMemoryStrdup.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlMemoryStrdup" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (char *)xmlMemoryStrdup((char const *)arg1);
  jsresult = SWIG_FromCharPtr((const char *)result);
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlMallocLoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  size_t arg1 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMallocLoc.");
  
  ecode1 = SWIG_AsVal_size_t(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlMallocLoc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlMallocLoc" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlMallocLoc" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (void *)xmlMallocLoc(SWIG_STD_MOVE(arg1),(char const *)arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  // free(arg2);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReallocLoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  size_t arg2 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *result = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReallocLoc.");
  
  arg1 = getSwigCObjectPtr(args[0]);ecode2 = SWIG_AsVal_size_t(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlReallocLoc" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlReallocLoc" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlReallocLoc" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (void *)xmlReallocLoc(arg1,SWIG_STD_MOVE(arg2),(char const *)arg3,arg4);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  // free(arg3);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlMallocAtomicLoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  size_t arg1 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMallocAtomicLoc.");
  
  ecode1 = SWIG_AsVal_size_t(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlMallocAtomicLoc" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlMallocAtomicLoc" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlMallocAtomicLoc" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (void *)xmlMallocAtomicLoc(SWIG_STD_MOVE(arg1),(char const *)arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  // free(arg2);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlMemStrdupLoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  char *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMemStrdupLoc.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlMemStrdupLoc" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlMemStrdupLoc" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlMemStrdupLoc" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (char *)xmlMemStrdupLoc((char const *)arg1,(char const *)arg2,arg3);
  jsresult = SWIG_FromCharPtr((const char *)result);
  // free(arg1);
  // free(arg2);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRegexpCompile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlRegexpPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRegexpCompile.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRegexpCompile" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlRegexpPtr)xmlRegexpCompile((unsigned char const *)arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlRegexp, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRegFreeRegexp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRegexpPtr arg1 = (xmlRegexpPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRegFreeRegexp.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRegexp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRegFreeRegexp" "', argument " "1"" of type '" "xmlRegexpPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRegexpPtr >(argp1);xmlRegFreeRegexp(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRegexpExec(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRegexpPtr arg1 = (xmlRegexpPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRegexpExec.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRegexp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRegexpExec" "', argument " "1"" of type '" "xmlRegexpPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRegexpPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlRegexpExec" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlRegexpExec(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRegexpPrint(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  xmlRegexpPtr arg2 = (xmlRegexpPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRegexpPrint.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRegexpPrint" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlRegexp, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlRegexpPrint" "', argument " "2"" of type '" "xmlRegexpPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlRegexpPtr >(argp2);xmlRegexpPrint(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRegexpIsDeterminist(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRegexpPtr arg1 = (xmlRegexpPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRegexpIsDeterminist.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRegexp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRegexpIsDeterminist" "', argument " "1"" of type '" "xmlRegexpPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRegexpPtr >(argp1);result = (int)xmlRegexpIsDeterminist(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRegNewExecCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRegexpPtr arg1 = (xmlRegexpPtr) 0 ;
  xmlRegExecCallbacks arg2 = (xmlRegExecCallbacks) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlRegExecCtxtPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRegNewExecCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRegexp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRegNewExecCtxt" "', argument " "1"" of type '" "xmlRegexpPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRegexpPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p__xmlRegExecCtxt_p_q_const__unsigned_char_p_void_p_void__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRegNewExecCtxt" "', argument " "2"" of type '" "xmlRegExecCallbacks""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);result = (xmlRegExecCtxtPtr)xmlRegNewExecCtxt(arg1,arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlRegExecCtxt, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRegFreeExecCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRegExecCtxtPtr arg1 = (xmlRegExecCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRegFreeExecCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRegExecCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRegFreeExecCtxt" "', argument " "1"" of type '" "xmlRegExecCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRegExecCtxtPtr >(argp1);xmlRegFreeExecCtxt(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRegExecPushString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRegExecCtxtPtr arg1 = (xmlRegExecCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRegExecPushString.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRegExecCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRegExecPushString" "', argument " "1"" of type '" "xmlRegExecCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRegExecCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlRegExecPushString" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }arg3 = getSwigCObjectPtr(args[2]);result = (int)xmlRegExecPushString(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRegExecPushString2(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRegExecCtxtPtr arg1 = (xmlRegExecCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRegExecPushString2.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRegExecCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRegExecPushString2" "', argument " "1"" of type '" "xmlRegExecCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRegExecCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlRegExecPushString2" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlRegExecPushString2" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }arg4 = getSwigCObjectPtr(args[3]);result = (int)xmlRegExecPushString2(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRegExecNextValues(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRegExecCtxtPtr arg1 = (xmlRegExecCtxtPtr) 0 ;
  int *arg2 = (int *) 0 ;
  int *arg3 = (int *) 0 ;
  xmlChar **arg4 = (xmlChar **) 0 ;
  int *arg5 = (int *) 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 result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRegExecNextValues.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRegExecCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRegExecNextValues" "', argument " "1"" of type '" "xmlRegExecCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRegExecCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlRegExecNextValues" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlRegExecNextValues" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlRegExecNextValues" "', argument " "4"" of type '" "xmlChar **""'"); 
  }
  arg4 = reinterpret_cast< xmlChar ** >(argp4);res5 = SWIG_ConvertPtr(args[4], &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlRegExecNextValues" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = reinterpret_cast< int * >(argp5);result = (int)xmlRegExecNextValues(arg1,arg2,arg3,arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRegExecErrInfo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRegExecCtxtPtr arg1 = (xmlRegExecCtxtPtr) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  int *arg3 = (int *) 0 ;
  int *arg4 = (int *) 0 ;
  xmlChar **arg5 = (xmlChar **) 0 ;
  int *arg6 = (int *) 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 result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRegExecErrInfo.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRegExecCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRegExecErrInfo" "', argument " "1"" of type '" "xmlRegExecCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRegExecCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlRegExecErrInfo" "', argument " "2"" of type '" "xmlChar const **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlRegExecErrInfo" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlRegExecErrInfo" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);res5 = SWIG_ConvertPtr(args[4], &argp5,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlRegExecErrInfo" "', argument " "5"" of type '" "xmlChar **""'"); 
  }
  arg5 = reinterpret_cast< xmlChar ** >(argp5);res6 = SWIG_ConvertPtr(args[5], &argp6,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlRegExecErrInfo" "', argument " "6"" of type '" "int *""'"); 
  }
  arg6 = reinterpret_cast< int * >(argp6);result = (int)xmlRegExecErrInfo(arg1,(unsigned char const **)arg2,arg3,arg4,arg5,arg6);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_BASE_BUFFER_SIZE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(4096));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_BUFFER_ALLOC_DOUBLEIT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_BUFFER_ALLOC_DOUBLEIT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_BUFFER_ALLOC_EXACT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_BUFFER_ALLOC_EXACT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_BUFFER_ALLOC_IMMUTABLE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_BUFFER_ALLOC_IMMUTABLE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_BUFFER_ALLOC_IO_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_BUFFER_ALLOC_IO));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_BUFFER_ALLOC_HYBRID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_BUFFER_ALLOC_HYBRID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_BUFFER_ALLOC_BOUNDED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_BUFFER_ALLOC_BOUNDED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlBuffer_content_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlBuffer *arg1 = (_xmlBuffer *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlBuffer_content_set" "', argument " "1"" of type '" "_xmlBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlBuffer * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlBuffer_content_set" "', argument " "2"" of type '" "xmlChar *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->content = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlBuffer_content_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlBuffer *arg1 = (_xmlBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlBuffer_content_get" "', argument " "1"" of type '" "_xmlBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlBuffer * >(argp1);result = (xmlChar *) ((arg1)->content);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlBuffer_use_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlBuffer *arg1 = (_xmlBuffer *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlBuffer_use_set" "', argument " "1"" of type '" "_xmlBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlBuffer * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlBuffer_use_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);if (arg1) (arg1)->use = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlBuffer_use_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlBuffer *arg1 = (_xmlBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlBuffer_use_get" "', argument " "1"" of type '" "_xmlBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlBuffer * >(argp1);result = (unsigned int) ((arg1)->use);
  jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlBuffer_size_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlBuffer *arg1 = (_xmlBuffer *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlBuffer_size_set" "', argument " "1"" of type '" "_xmlBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlBuffer * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlBuffer_size_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);if (arg1) (arg1)->size = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlBuffer_size_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlBuffer *arg1 = (_xmlBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlBuffer_size_get" "', argument " "1"" of type '" "_xmlBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlBuffer * >(argp1);result = (unsigned int) ((arg1)->size);
  jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlBuffer_alloc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlBuffer *arg1 = (_xmlBuffer *) 0 ;
  xmlBufferAllocationScheme arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlBuffer_alloc_set" "', argument " "1"" of type '" "_xmlBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlBuffer * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlBuffer_alloc_set" "', argument " "2"" of type '" "xmlBufferAllocationScheme""'");
  } 
  arg2 = static_cast< xmlBufferAllocationScheme >(val2);if (arg1) (arg1)->alloc = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlBuffer_alloc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlBuffer *arg1 = (_xmlBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlBufferAllocationScheme result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlBuffer_alloc_get" "', argument " "1"" of type '" "_xmlBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlBuffer * >(argp1);result = (xmlBufferAllocationScheme) ((arg1)->alloc);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlBuffer_contentIO_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlBuffer *arg1 = (_xmlBuffer *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlBuffer_contentIO_set" "', argument " "1"" of type '" "_xmlBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlBuffer * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlBuffer_contentIO_set" "', argument " "2"" of type '" "xmlChar *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->contentIO = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlBuffer_contentIO_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlBuffer *arg1 = (_xmlBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlBuffer_contentIO_get" "', argument " "1"" of type '" "_xmlBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlBuffer * >(argp1);result = (xmlChar *) ((arg1)->contentIO);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlBuffer(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlBuffer *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlBuffer.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlBuffer.");
  result = (_xmlBuffer *)new _xmlBuffer();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlBuffer, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlBuffer(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlBuffer * arg1 = (_xmlBuffer *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap_xmlBufContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBuf *arg1 = (xmlBuf *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufContent.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufContent" "', argument " "1"" of type '" "xmlBuf const *""'"); 
  }
  arg1 = reinterpret_cast< xmlBuf * >(argp1);result = (xmlChar *)xmlBufContent((_xmlBuf const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufEnd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufPtr arg1 = (xmlBufPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufEnd.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufEnd" "', argument " "1"" of type '" "xmlBufPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufPtr >(argp1);result = (xmlChar *)xmlBufEnd(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufUse(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufPtr arg1 = (xmlBufPtr) (xmlBufPtr)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufUse.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufUse" "', argument " "1"" of type '" "xmlBufPtr const""'"); 
  }
  arg1 = reinterpret_cast< xmlBufPtr >(argp1);result = xmlBufUse(arg1);
  jsresult = SWIG_From_size_t(static_cast< size_t >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufShrink(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufPtr arg1 = (xmlBufPtr) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufShrink.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufShrink" "', argument " "1"" of type '" "xmlBufPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufPtr >(argp1);ecode2 = SWIG_AsVal_size_t(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlBufShrink" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);result = xmlBufShrink(arg1,SWIG_STD_MOVE(arg2));
  jsresult = SWIG_From_size_t(static_cast< size_t >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_ELEMENT_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ELEMENT_NODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ATTRIBUTE_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ATTRIBUTE_NODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_TEXT_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_TEXT_NODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CDATA_SECTION_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CDATA_SECTION_NODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ENTITY_REF_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ENTITY_REF_NODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ENTITY_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ENTITY_NODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PI_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PI_NODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_COMMENT_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_COMMENT_NODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DOCUMENT_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DOCUMENT_NODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DOCUMENT_TYPE_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DOCUMENT_TYPE_NODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DOCUMENT_FRAG_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DOCUMENT_FRAG_NODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_NOTATION_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_NOTATION_NODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_HTML_DOCUMENT_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_HTML_DOCUMENT_NODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_NODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ELEMENT_DECL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ELEMENT_DECL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ATTRIBUTE_DECL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ATTRIBUTE_DECL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ENTITY_DECL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ENTITY_DECL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_NAMESPACE_DECL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_NAMESPACE_DECL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_START_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_START));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_END_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_END));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DOCB_DOCUMENT_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(21));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNotation_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNotation *arg1 = (_xmlNotation *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlNotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlNotation_name_set" "', argument " "1"" of type '" "_xmlNotation *""'"); 
  }
  arg1 = reinterpret_cast< _xmlNotation * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlNotation_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->name = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNotation_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNotation *arg1 = (_xmlNotation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlNotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlNotation_name_get" "', argument " "1"" of type '" "_xmlNotation *""'"); 
  }
  arg1 = reinterpret_cast< _xmlNotation * >(argp1);result = (xmlChar *) ((arg1)->name);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNotation_PublicID_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNotation *arg1 = (_xmlNotation *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlNotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlNotation_PublicID_set" "', argument " "1"" of type '" "_xmlNotation *""'"); 
  }
  arg1 = reinterpret_cast< _xmlNotation * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlNotation_PublicID_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->PublicID = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNotation_PublicID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNotation *arg1 = (_xmlNotation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlNotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlNotation_PublicID_get" "', argument " "1"" of type '" "_xmlNotation *""'"); 
  }
  arg1 = reinterpret_cast< _xmlNotation * >(argp1);result = (xmlChar *) ((arg1)->PublicID);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNotation_SystemID_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNotation *arg1 = (_xmlNotation *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlNotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlNotation_SystemID_set" "', argument " "1"" of type '" "_xmlNotation *""'"); 
  }
  arg1 = reinterpret_cast< _xmlNotation * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlNotation_SystemID_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->SystemID = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNotation_SystemID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNotation *arg1 = (_xmlNotation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlNotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlNotation_SystemID_get" "', argument " "1"" of type '" "_xmlNotation *""'"); 
  }
  arg1 = reinterpret_cast< _xmlNotation * >(argp1);result = (xmlChar *) ((arg1)->SystemID);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlNotation(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlNotation *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlNotation.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlNotation.");
  result = (_xmlNotation *)new _xmlNotation();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlNotation, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlNotation(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlNotation * arg1 = (_xmlNotation *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue exports_XML_ATTRIBUTE_CDATA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ATTRIBUTE_CDATA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ATTRIBUTE_ID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ATTRIBUTE_ID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ATTRIBUTE_IDREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ATTRIBUTE_IDREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ATTRIBUTE_IDREFS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ATTRIBUTE_IDREFS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ATTRIBUTE_ENTITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ATTRIBUTE_ENTITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ATTRIBUTE_ENTITIES_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ATTRIBUTE_ENTITIES));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ATTRIBUTE_NMTOKEN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ATTRIBUTE_NMTOKEN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ATTRIBUTE_NMTOKENS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ATTRIBUTE_NMTOKENS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ATTRIBUTE_ENUMERATION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ATTRIBUTE_ENUMERATION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ATTRIBUTE_NOTATION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ATTRIBUTE_NOTATION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ATTRIBUTE_NONE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ATTRIBUTE_NONE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ATTRIBUTE_REQUIRED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ATTRIBUTE_REQUIRED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ATTRIBUTE_IMPLIED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ATTRIBUTE_IMPLIED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ATTRIBUTE_FIXED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ATTRIBUTE_FIXED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEnumeration_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEnumeration *arg1 = (_xmlEnumeration *) 0 ;
  _xmlEnumeration *arg2 = (_xmlEnumeration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlEnumeration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlEnumeration_next_set" "', argument " "1"" of type '" "_xmlEnumeration *""'"); 
  }
  arg1 = reinterpret_cast< _xmlEnumeration * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlEnumeration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlEnumeration_next_set" "', argument " "2"" of type '" "_xmlEnumeration *""'"); 
  }
  arg2 = reinterpret_cast< _xmlEnumeration * >(argp2);if (arg1) (arg1)->next = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEnumeration_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEnumeration *arg1 = (_xmlEnumeration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlEnumeration *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlEnumeration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlEnumeration_next_get" "', argument " "1"" of type '" "_xmlEnumeration *""'"); 
  }
  arg1 = reinterpret_cast< _xmlEnumeration * >(argp1);result = (_xmlEnumeration *) ((arg1)->next);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlEnumeration, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEnumeration_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEnumeration *arg1 = (_xmlEnumeration *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlEnumeration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlEnumeration_name_set" "', argument " "1"" of type '" "_xmlEnumeration *""'"); 
  }
  arg1 = reinterpret_cast< _xmlEnumeration * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlEnumeration_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->name = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEnumeration_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEnumeration *arg1 = (_xmlEnumeration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlEnumeration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlEnumeration_name_get" "', argument " "1"" of type '" "_xmlEnumeration *""'"); 
  }
  arg1 = reinterpret_cast< _xmlEnumeration * >(argp1);result = (xmlChar *) ((arg1)->name);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlEnumeration(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlEnumeration *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlEnumeration.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlEnumeration.");
  result = (_xmlEnumeration *)new _xmlEnumeration();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlEnumeration, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlEnumeration(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlEnumeration * arg1 = (_xmlEnumeration *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlAttribute__private_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute__private_set" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->_private = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttribute__private_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute__private_get" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);result = (void *) ((arg1)->_private);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttribute_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  xmlElementType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_type_set" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlAttribute_type_set" "', argument " "2"" of type '" "xmlElementType""'");
  } 
  arg2 = static_cast< xmlElementType >(val2);if (arg1) (arg1)->type = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttribute_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlElementType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_type_get" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);result = (xmlElementType) ((arg1)->type);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttribute_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_name_set" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlAttribute_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->name = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttribute_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_name_get" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);result = (xmlChar *) ((arg1)->name);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttribute_children_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_children_set" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlAttribute_children_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);if (arg1) (arg1)->children = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttribute_children_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_children_get" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);result = (_xmlNode *) ((arg1)->children);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttribute_last_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_last_set" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlAttribute_last_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);if (arg1) (arg1)->last = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttribute_last_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_last_get" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);result = (_xmlNode *) ((arg1)->last);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttribute_parent_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  _xmlDtd *arg2 = (_xmlDtd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_parent_set" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlAttribute_parent_set', argument 2 of type '_xmlDtd *'"); 
  }
  arg2 = (_xmlDtd *) arg20;if (arg1) (arg1)->parent = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttribute_parent_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlDtd *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_parent_get" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);result = (_xmlDtd *) ((arg1)->parent);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDtd);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttribute_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_next_set" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlAttribute_next_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);if (arg1) (arg1)->next = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttribute_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_next_get" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);result = (_xmlNode *) ((arg1)->next);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttribute_prev_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_prev_set" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlAttribute_prev_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);if (arg1) (arg1)->prev = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttribute_prev_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_prev_get" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);result = (_xmlNode *) ((arg1)->prev);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttribute_doc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  _xmlDoc *arg2 = (_xmlDoc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_doc_set" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlAttribute_doc_set', argument 2 of type '_xmlDoc *'"); 
  }
  arg2 = (_xmlDoc *) arg20;if (arg1) (arg1)->doc = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttribute_doc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlDoc *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_doc_get" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);result = (_xmlDoc *) ((arg1)->doc);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttribute_nexth_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  _xmlAttribute *arg2 = (_xmlAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_nexth_set" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlAttribute, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlAttribute_nexth_set" "', argument " "2"" of type '" "_xmlAttribute *""'"); 
  }
  arg2 = reinterpret_cast< _xmlAttribute * >(argp2);if (arg1) (arg1)->nexth = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttribute_nexth_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlAttribute *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_nexth_get" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);result = (_xmlAttribute *) ((arg1)->nexth);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAttribute, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttribute_atype_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  xmlAttributeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_atype_set" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlAttribute_atype_set" "', argument " "2"" of type '" "xmlAttributeType""'");
  } 
  arg2 = static_cast< xmlAttributeType >(val2);if (arg1) (arg1)->atype = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttribute_atype_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlAttributeType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_atype_get" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);result = (xmlAttributeType) ((arg1)->atype);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttribute_def_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  xmlAttributeDefault arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_def_set" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlAttribute_def_set" "', argument " "2"" of type '" "xmlAttributeDefault""'");
  } 
  arg2 = static_cast< xmlAttributeDefault >(val2);if (arg1) (arg1)->def = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttribute_def_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlAttributeDefault result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_def_get" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);result = (xmlAttributeDefault) ((arg1)->def);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttribute_defaultValue_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_defaultValue_set" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlAttribute_defaultValue_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->defaultValue = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttribute_defaultValue_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_defaultValue_get" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);result = (xmlChar *) ((arg1)->defaultValue);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttribute_tree_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  xmlEnumerationPtr arg2 = (xmlEnumerationPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_tree_set" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlEnumeration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlAttribute_tree_set" "', argument " "2"" of type '" "xmlEnumerationPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlEnumerationPtr >(argp2);if (arg1) (arg1)->tree = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttribute_tree_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlEnumerationPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_tree_get" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);result = (xmlEnumerationPtr) ((arg1)->tree);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlEnumeration, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttribute_prefix_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_prefix_set" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlAttribute_prefix_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->prefix = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttribute_prefix_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_prefix_get" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);result = (xmlChar *) ((arg1)->prefix);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttribute_elem_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_elem_set" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlAttribute_elem_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->elem = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttribute_elem_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttribute *arg1 = (_xmlAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlAttribute_elem_get" "', argument " "1"" of type '" "_xmlAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlAttribute * >(argp1);result = (xmlChar *) ((arg1)->elem);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlAttribute(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlAttribute *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlAttribute.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlAttribute.");
  result = (_xmlAttribute *)new _xmlAttribute();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlAttribute, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlAttribute(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlAttribute * arg1 = (_xmlAttribute *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue exports_XML_ELEMENT_CONTENT_PCDATA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ELEMENT_CONTENT_PCDATA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ELEMENT_CONTENT_ELEMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ELEMENT_CONTENT_ELEMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ELEMENT_CONTENT_SEQ_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ELEMENT_CONTENT_SEQ));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ELEMENT_CONTENT_OR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ELEMENT_CONTENT_OR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ELEMENT_CONTENT_ONCE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ELEMENT_CONTENT_ONCE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ELEMENT_CONTENT_OPT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ELEMENT_CONTENT_OPT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ELEMENT_CONTENT_MULT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ELEMENT_CONTENT_MULT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ELEMENT_CONTENT_PLUS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ELEMENT_CONTENT_PLUS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElementContent_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElementContent *arg1 = (_xmlElementContent *) 0 ;
  xmlElementContentType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlElementContent_type_set" "', argument " "1"" of type '" "_xmlElementContent *""'"); 
  }
  arg1 = reinterpret_cast< _xmlElementContent * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlElementContent_type_set" "', argument " "2"" of type '" "xmlElementContentType""'");
  } 
  arg2 = static_cast< xmlElementContentType >(val2);if (arg1) (arg1)->type = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElementContent_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElementContent *arg1 = (_xmlElementContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlElementContentType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlElementContent_type_get" "', argument " "1"" of type '" "_xmlElementContent *""'"); 
  }
  arg1 = reinterpret_cast< _xmlElementContent * >(argp1);result = (xmlElementContentType) ((arg1)->type);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElementContent_ocur_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElementContent *arg1 = (_xmlElementContent *) 0 ;
  xmlElementContentOccur arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlElementContent_ocur_set" "', argument " "1"" of type '" "_xmlElementContent *""'"); 
  }
  arg1 = reinterpret_cast< _xmlElementContent * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlElementContent_ocur_set" "', argument " "2"" of type '" "xmlElementContentOccur""'");
  } 
  arg2 = static_cast< xmlElementContentOccur >(val2);if (arg1) (arg1)->ocur = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElementContent_ocur_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElementContent *arg1 = (_xmlElementContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlElementContentOccur result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlElementContent_ocur_get" "', argument " "1"" of type '" "_xmlElementContent *""'"); 
  }
  arg1 = reinterpret_cast< _xmlElementContent * >(argp1);result = (xmlElementContentOccur) ((arg1)->ocur);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElementContent_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElementContent *arg1 = (_xmlElementContent *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlElementContent_name_set" "', argument " "1"" of type '" "_xmlElementContent *""'"); 
  }
  arg1 = reinterpret_cast< _xmlElementContent * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlElementContent_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->name = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElementContent_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElementContent *arg1 = (_xmlElementContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlElementContent_name_get" "', argument " "1"" of type '" "_xmlElementContent *""'"); 
  }
  arg1 = reinterpret_cast< _xmlElementContent * >(argp1);result = (xmlChar *) ((arg1)->name);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElementContent_c1_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElementContent *arg1 = (_xmlElementContent *) 0 ;
  _xmlElementContent *arg2 = (_xmlElementContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlElementContent_c1_set" "', argument " "1"" of type '" "_xmlElementContent *""'"); 
  }
  arg1 = reinterpret_cast< _xmlElementContent * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlElementContent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlElementContent_c1_set" "', argument " "2"" of type '" "_xmlElementContent *""'"); 
  }
  arg2 = reinterpret_cast< _xmlElementContent * >(argp2);if (arg1) (arg1)->c1 = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElementContent_c1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElementContent *arg1 = (_xmlElementContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlElementContent *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlElementContent_c1_get" "', argument " "1"" of type '" "_xmlElementContent *""'"); 
  }
  arg1 = reinterpret_cast< _xmlElementContent * >(argp1);result = (_xmlElementContent *) ((arg1)->c1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlElementContent, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElementContent_c2_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElementContent *arg1 = (_xmlElementContent *) 0 ;
  _xmlElementContent *arg2 = (_xmlElementContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlElementContent_c2_set" "', argument " "1"" of type '" "_xmlElementContent *""'"); 
  }
  arg1 = reinterpret_cast< _xmlElementContent * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlElementContent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlElementContent_c2_set" "', argument " "2"" of type '" "_xmlElementContent *""'"); 
  }
  arg2 = reinterpret_cast< _xmlElementContent * >(argp2);if (arg1) (arg1)->c2 = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElementContent_c2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElementContent *arg1 = (_xmlElementContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlElementContent *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlElementContent_c2_get" "', argument " "1"" of type '" "_xmlElementContent *""'"); 
  }
  arg1 = reinterpret_cast< _xmlElementContent * >(argp1);result = (_xmlElementContent *) ((arg1)->c2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlElementContent, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElementContent_parent_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElementContent *arg1 = (_xmlElementContent *) 0 ;
  _xmlElementContent *arg2 = (_xmlElementContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlElementContent_parent_set" "', argument " "1"" of type '" "_xmlElementContent *""'"); 
  }
  arg1 = reinterpret_cast< _xmlElementContent * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlElementContent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlElementContent_parent_set" "', argument " "2"" of type '" "_xmlElementContent *""'"); 
  }
  arg2 = reinterpret_cast< _xmlElementContent * >(argp2);if (arg1) (arg1)->parent = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElementContent_parent_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElementContent *arg1 = (_xmlElementContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlElementContent *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlElementContent_parent_get" "', argument " "1"" of type '" "_xmlElementContent *""'"); 
  }
  arg1 = reinterpret_cast< _xmlElementContent * >(argp1);result = (_xmlElementContent *) ((arg1)->parent);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlElementContent, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElementContent_prefix_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElementContent *arg1 = (_xmlElementContent *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlElementContent_prefix_set" "', argument " "1"" of type '" "_xmlElementContent *""'"); 
  }
  arg1 = reinterpret_cast< _xmlElementContent * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlElementContent_prefix_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->prefix = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElementContent_prefix_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElementContent *arg1 = (_xmlElementContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlElementContent_prefix_get" "', argument " "1"" of type '" "_xmlElementContent *""'"); 
  }
  arg1 = reinterpret_cast< _xmlElementContent * >(argp1);result = (xmlChar *) ((arg1)->prefix);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlElementContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlElementContent *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlElementContent.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlElementContent.");
  result = (_xmlElementContent *)new _xmlElementContent();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlElementContent, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlElementContent(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlElementContent * arg1 = (_xmlElementContent *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue exports_XML_ELEMENT_TYPE_UNDEFINED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ELEMENT_TYPE_UNDEFINED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ELEMENT_TYPE_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ELEMENT_TYPE_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ELEMENT_TYPE_ANY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ELEMENT_TYPE_ANY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ELEMENT_TYPE_MIXED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ELEMENT_TYPE_MIXED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ELEMENT_TYPE_ELEMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ELEMENT_TYPE_ELEMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElement__private_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement__private_set', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlElement__private_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);_xmlElement__private_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElement__private_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement__private_get', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;result = (int)_xmlElement__private_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElement_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  xmlElementType arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_type_set', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlElement_type_set" "', argument " "2"" of type '" "xmlElementType""'");
  } 
  arg2 = static_cast< xmlElementType >(val2);_xmlElement_type_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElement_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlElementType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_type_get', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;result = (xmlElementType)_xmlElement_type_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElement_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_name_set', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlElement_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlElement_name_set(arg1,(unsigned char const *)arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElement_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_name_get', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;result = (xmlChar *)_xmlElement_name_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElement_children_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_children_set', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlElement_children_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlElement_children_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElement_children_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_children_get', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;result = (_xmlNode *)_xmlElement_children_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElement_last_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_last_set', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlElement_last_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlElement_last_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElement_last_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_last_get', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;result = (_xmlNode *)_xmlElement_last_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElement_parent_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  _xmlDtd *arg2 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_parent_set', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlElement_parent_set', argument 2 of type '_xmlDtd *'"); 
  }
  arg2 = (_xmlDtd *) arg20;_xmlElement_parent_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElement_parent_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlDtd *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_parent_get', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;result = (_xmlDtd *)_xmlElement_parent_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDtd);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElement_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_next_set', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlElement_next_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlElement_next_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElement_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_next_get', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;result = (_xmlNode *)_xmlElement_next_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElement_prev_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_prev_set', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlElement_prev_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlElement_prev_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElement_prev_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_prev_get', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;result = (_xmlNode *)_xmlElement_prev_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElement_doc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  _xmlDoc *arg2 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_doc_set', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlElement_doc_set', argument 2 of type '_xmlDoc *'"); 
  }
  arg2 = (_xmlDoc *) arg20;_xmlElement_doc_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElement_doc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlDoc *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_doc_get', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;result = (_xmlDoc *)_xmlElement_doc_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElement_etype_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  xmlElementTypeVal arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_etype_set', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlElement_etype_set" "', argument " "2"" of type '" "xmlElementTypeVal""'");
  } 
  arg2 = static_cast< xmlElementTypeVal >(val2);_xmlElement_etype_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElement_etype_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlElementTypeVal result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_etype_get', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;result = (xmlElementTypeVal)_xmlElement_etype_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElement_content_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  xmlElementContentPtr arg2 = (xmlElementContentPtr) 0 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_content_set', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlElementContent, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlElement_content_set" "', argument " "2"" of type '" "xmlElementContentPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlElementContentPtr >(argp2);_xmlElement_content_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElement_content_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlElementContentPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_content_get', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;result = (xmlElementContentPtr)_xmlElement_content_get(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlElementContent, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElement_attributes_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  xmlAttributePtr arg2 = (xmlAttributePtr) 0 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_attributes_set', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlAttribute, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlElement_attributes_set" "', argument " "2"" of type '" "xmlAttributePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlAttributePtr >(argp2);_xmlElement_attributes_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElement_attributes_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlAttributePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_attributes_get', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;result = (xmlAttributePtr)_xmlElement_attributes_get(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAttribute, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElement_prefix_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_prefix_set', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlElement_prefix_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlElement_prefix_set(arg1,(unsigned char const *)arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElement_prefix_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_prefix_get', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;result = (xmlChar *)_xmlElement_prefix_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlElement_contModel_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  xmlRegexpPtr arg2 = (xmlRegexpPtr) 0 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_contModel_set', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlRegexp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlElement_contModel_set" "', argument " "2"" of type '" "xmlRegexpPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlRegexpPtr >(argp2);_xmlElement_contModel_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlElement_contModel_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlElement *arg1 = (_xmlElement *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlRegexpPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlElement_contModel_get', argument 1 of type '_xmlElement *'"); 
  }
  arg1 = (_xmlElement *) arg10;result = (xmlRegexpPtr)_xmlElement_contModel_get(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlRegexp, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}

SWIGINTERN void delete__xmlElement(_xmlElement *self){
        destroyWrap((xmlNode*)self);
    }

static void _wrap_delete__xmlElement(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlElement * arg1 = (_xmlElement *)proxy->swigCObject;
    delete__xmlElement(arg1);
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap_new__xmlElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlElement *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlElement.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlElement.");
  result = (_xmlElement *)new _xmlElement();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlElement, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap__xmlNs_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNs *arg1 = (_xmlNs *) 0 ;
  _xmlNs *arg2 = (_xmlNs *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNs_next_set', argument 1 of type '_xmlNs *'"); 
  }
  arg1 = (_xmlNs *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlNs_next_set', argument 2 of type '_xmlNs *'"); 
  }
  arg2 = (_xmlNs *) arg20;_xmlNs_next_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNs_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNs *arg1 = (_xmlNs *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNs *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNs_next_get', argument 1 of type '_xmlNs *'"); 
  }
  arg1 = (_xmlNs *) arg10;result = (_xmlNs *)_xmlNs_next_get(arg1);
  jsresult = createWrapNs(result, SWIGTYPE_p__xmlNs);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNs_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNs *arg1 = (_xmlNs *) 0 ;
  xmlNsType arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNs_type_set', argument 1 of type '_xmlNs *'"); 
  }
  arg1 = (_xmlNs *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlNs_type_set" "', argument " "2"" of type '" "xmlNsType""'");
  } 
  arg2 = static_cast< xmlNsType >(val2);_xmlNs_type_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNs_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNs *arg1 = (_xmlNs *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlNsType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNs_type_get', argument 1 of type '_xmlNs *'"); 
  }
  arg1 = (_xmlNs *) arg10;result = (xmlNsType)_xmlNs_type_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNs_href_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNs *arg1 = (_xmlNs *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNs_href_set', argument 1 of type '_xmlNs *'"); 
  }
  arg1 = (_xmlNs *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlNs_href_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlNs_href_set(arg1,(unsigned char const *)arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNs_href_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNs *arg1 = (_xmlNs *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNs_href_get', argument 1 of type '_xmlNs *'"); 
  }
  arg1 = (_xmlNs *) arg10;result = (xmlChar *)_xmlNs_href_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNs_prefix_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNs *arg1 = (_xmlNs *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNs_prefix_set', argument 1 of type '_xmlNs *'"); 
  }
  arg1 = (_xmlNs *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlNs_prefix_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlNs_prefix_set(arg1,(unsigned char const *)arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNs_prefix_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNs *arg1 = (_xmlNs *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNs_prefix_get', argument 1 of type '_xmlNs *'"); 
  }
  arg1 = (_xmlNs *) arg10;result = (xmlChar *)_xmlNs_prefix_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNs__private_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNs *arg1 = (_xmlNs *) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNs__private_set', argument 1 of type '_xmlNs *'"); 
  }
  arg1 = (_xmlNs *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlNs__private_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);_xmlNs__private_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNs__private_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNs *arg1 = (_xmlNs *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNs__private_get', argument 1 of type '_xmlNs *'"); 
  }
  arg1 = (_xmlNs *) arg10;result = (int)_xmlNs__private_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNs_context_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNs *arg1 = (_xmlNs *) 0 ;
  _xmlDoc *arg2 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNs_context_set', argument 1 of type '_xmlNs *'"); 
  }
  arg1 = (_xmlNs *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlNs_context_set', argument 2 of type '_xmlDoc *'"); 
  }
  arg2 = (_xmlDoc *) arg20;_xmlNs_context_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNs_context_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNs *arg1 = (_xmlNs *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlDoc *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNs_context_get', argument 1 of type '_xmlNs *'"); 
  }
  arg1 = (_xmlNs *) arg10;result = (_xmlDoc *)_xmlNs_context_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}

SWIGINTERN void delete__xmlNs(_xmlNs *self){
        // printf("destroyNs %i\n", self);
        SWIGV8_Proxy* wrap = (SWIGV8_Proxy*) self->_private;

        if (wrap != NULL) {
            resetWrap(wrap);
            if (wrap->doc != NULL && wrap->doc->_private != NULL) {
                getXmlNodePrivate((xmlNode*) wrap->doc)->Unref();
            }
        }
        
        self->_private = NULL;
    }

static void _wrap_delete__xmlNs(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlNs * arg1 = (_xmlNs *)proxy->swigCObject;
    delete__xmlNs(arg1);
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap_new__xmlNs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlNs *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlNs.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlNs.");
  result = (_xmlNs *)new _xmlNs();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlNs, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap__xmlDtd__private_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd__private_set', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlDtd__private_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);_xmlDtd__private_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDtd__private_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd__private_get', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;result = (int)_xmlDtd__private_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDtd_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  xmlElementType arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_type_set', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlDtd_type_set" "', argument " "2"" of type '" "xmlElementType""'");
  } 
  arg2 = static_cast< xmlElementType >(val2);_xmlDtd_type_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDtd_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlElementType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_type_get', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;result = (xmlElementType)_xmlDtd_type_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDtd_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_name_set', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlDtd_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlDtd_name_set(arg1,(unsigned char const *)arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDtd_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_name_get', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;result = (xmlChar *)_xmlDtd_name_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDtd_children_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_children_set', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlDtd_children_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlDtd_children_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDtd_children_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_children_get', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;result = (_xmlNode *)_xmlDtd_children_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDtd_last_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_last_set', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlDtd_last_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlDtd_last_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDtd_last_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_last_get', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;result = (_xmlNode *)_xmlDtd_last_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDtd_parent_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  _xmlDoc *arg2 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_parent_set', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlDtd_parent_set', argument 2 of type '_xmlDoc *'"); 
  }
  arg2 = (_xmlDoc *) arg20;_xmlDtd_parent_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDtd_parent_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlDoc *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_parent_get', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;result = (_xmlDoc *)_xmlDtd_parent_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDtd_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_next_set', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlDtd_next_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlDtd_next_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDtd_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_next_get', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;result = (_xmlNode *)_xmlDtd_next_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDtd_prev_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_prev_set', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlDtd_prev_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlDtd_prev_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDtd_prev_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_prev_get', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;result = (_xmlNode *)_xmlDtd_prev_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDtd_doc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  _xmlDoc *arg2 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_doc_set', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlDtd_doc_set', argument 2 of type '_xmlDoc *'"); 
  }
  arg2 = (_xmlDoc *) arg20;_xmlDtd_doc_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDtd_doc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlDoc *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_doc_get', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;result = (_xmlDoc *)_xmlDtd_doc_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDtd_notations_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  void *arg2 = (void *) 0 ;
  int res1 ;
  void *arg10 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_notations_set', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;arg2 = getSwigCObjectPtr(value);_xmlDtd_notations_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDtd_notations_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_notations_get', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;result = (void *)_xmlDtd_notations_get(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDtd_elements_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  void *arg2 = (void *) 0 ;
  int res1 ;
  void *arg10 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_elements_set', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;arg2 = getSwigCObjectPtr(value);_xmlDtd_elements_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDtd_elements_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_elements_get', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;result = (void *)_xmlDtd_elements_get(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDtd_attributes_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  void *arg2 = (void *) 0 ;
  int res1 ;
  void *arg10 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_attributes_set', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;arg2 = getSwigCObjectPtr(value);_xmlDtd_attributes_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDtd_attributes_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_attributes_get', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;result = (void *)_xmlDtd_attributes_get(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDtd_entities_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  void *arg2 = (void *) 0 ;
  int res1 ;
  void *arg10 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_entities_set', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;arg2 = getSwigCObjectPtr(value);_xmlDtd_entities_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDtd_entities_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_entities_get', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;result = (void *)_xmlDtd_entities_get(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDtd_ExternalID_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_ExternalID_set', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlDtd_ExternalID_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlDtd_ExternalID_set(arg1,(unsigned char const *)arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDtd_ExternalID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_ExternalID_get', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;result = (xmlChar *)_xmlDtd_ExternalID_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDtd_SystemID_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_SystemID_set', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlDtd_SystemID_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlDtd_SystemID_set(arg1,(unsigned char const *)arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDtd_SystemID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_SystemID_get', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;result = (xmlChar *)_xmlDtd_SystemID_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDtd_pentities_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  void *arg2 = (void *) 0 ;
  int res1 ;
  void *arg10 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_pentities_set', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;arg2 = getSwigCObjectPtr(value);_xmlDtd_pentities_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDtd_pentities_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDtd *arg1 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDtd_pentities_get', argument 1 of type '_xmlDtd *'"); 
  }
  arg1 = (_xmlDtd *) arg10;result = (void *)_xmlDtd_pentities_get(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}

SWIGINTERN void delete__xmlDtd(_xmlDtd *self){
        destroyWrap((xmlNode*)self);
    }

static void _wrap_delete__xmlDtd(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlDtd * arg1 = (_xmlDtd *)proxy->swigCObject;
    delete__xmlDtd(arg1);
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap_new__xmlDtd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlDtd *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlDtd.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlDtd.");
  result = (_xmlDtd *)new _xmlDtd();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlDtd, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap__xmlAttr_id_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  _xmlID *arg2 = (_xmlID *) 0 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_id_set', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlAttr_id_set" "', argument " "2"" of type '" "_xmlID *""'"); 
  }
  arg2 = reinterpret_cast< _xmlID * >(argp2);if (arg1) (arg1)->id = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttr_id_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlID *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_id_get', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;result = (_xmlID *) ((arg1)->id);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlID, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttr__private_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr__private_set', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlAttr__private_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);_xmlAttr__private_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttr__private_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr__private_get', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;result = (int)_xmlAttr__private_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttr_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  xmlElementType arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_type_set', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlAttr_type_set" "', argument " "2"" of type '" "xmlElementType""'");
  } 
  arg2 = static_cast< xmlElementType >(val2);_xmlAttr_type_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttr_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlElementType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_type_get', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;result = (xmlElementType)_xmlAttr_type_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttr_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_name_set', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlAttr_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlAttr_name_set(arg1,(unsigned char const *)arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttr_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_name_get', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;result = (xmlChar *)_xmlAttr_name_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttr_children_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_children_set', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlAttr_children_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlAttr_children_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttr_children_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_children_get', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;result = (_xmlNode *)_xmlAttr_children_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttr_last_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_last_set', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlAttr_last_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlAttr_last_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttr_last_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_last_get', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;result = (_xmlNode *)_xmlAttr_last_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttr_parent_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_parent_set', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlAttr_parent_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlAttr_parent_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttr_parent_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_parent_get', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;result = (_xmlNode *)_xmlAttr_parent_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttr_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  _xmlAttr *arg2 = (_xmlAttr *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_next_set', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlAttr_next_set', argument 2 of type '_xmlAttr *'"); 
  }
  arg2 = (_xmlAttr *) arg20;_xmlAttr_next_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttr_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlAttr *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_next_get', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;result = (_xmlAttr *)_xmlAttr_next_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlAttr);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttr_prev_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  _xmlAttr *arg2 = (_xmlAttr *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_prev_set', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlAttr_prev_set', argument 2 of type '_xmlAttr *'"); 
  }
  arg2 = (_xmlAttr *) arg20;_xmlAttr_prev_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttr_prev_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlAttr *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_prev_get', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;result = (_xmlAttr *)_xmlAttr_prev_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlAttr);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttr_doc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  _xmlDoc *arg2 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_doc_set', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlAttr_doc_set', argument 2 of type '_xmlDoc *'"); 
  }
  arg2 = (_xmlDoc *) arg20;_xmlAttr_doc_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttr_doc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlDoc *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_doc_get', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;result = (_xmlDoc *)_xmlAttr_doc_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttr_ns_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  xmlNs *arg2 = (xmlNs *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_ns_set', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlAttr_ns_set', argument 2 of type 'xmlNs *'"); 
  }
  arg2 = (xmlNs *) arg20;_xmlAttr_ns_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttr_ns_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlNs *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_ns_get', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;result = (xmlNs *)_xmlAttr_ns_get(arg1);
  jsresult = createWrapNs(result, SWIGTYPE_p__xmlNs);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttr_atype_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  xmlAttributeType arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_atype_set', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlAttr_atype_set" "', argument " "2"" of type '" "xmlAttributeType""'");
  } 
  arg2 = static_cast< xmlAttributeType >(val2);_xmlAttr_atype_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttr_atype_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlAttributeType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_atype_get', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;result = (xmlAttributeType)_xmlAttr_atype_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlAttr_psvi_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  void *arg2 = (void *) 0 ;
  int res1 ;
  void *arg10 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_psvi_set', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;arg2 = getSwigCObjectPtr(value);_xmlAttr_psvi_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlAttr_psvi_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlAttr *arg1 = (_xmlAttr *) 0 ;
  int res1 ;
  void *arg10 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlAttr_psvi_get', argument 1 of type '_xmlAttr *'"); 
  }
  arg1 = (_xmlAttr *) arg10;result = (void *)_xmlAttr_psvi_get(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}

SWIGINTERN void delete__xmlAttr(_xmlAttr *self){
        destroyWrap((xmlNode*)self);
    }

static void _wrap_delete__xmlAttr(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlAttr * arg1 = (_xmlAttr *)proxy->swigCObject;
    delete__xmlAttr(arg1);
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap_new__xmlAttr(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlAttr *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlAttr.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlAttr.");
  result = (_xmlAttr *)new _xmlAttr();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlAttr, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap__xmlID_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlID *arg1 = (_xmlID *) 0 ;
  _xmlID *arg2 = (_xmlID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlID_next_set" "', argument " "1"" of type '" "_xmlID *""'"); 
  }
  arg1 = reinterpret_cast< _xmlID * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlID, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlID_next_set" "', argument " "2"" of type '" "_xmlID *""'"); 
  }
  arg2 = reinterpret_cast< _xmlID * >(argp2);if (arg1) (arg1)->next = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlID_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlID *arg1 = (_xmlID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlID *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlID_next_get" "', argument " "1"" of type '" "_xmlID *""'"); 
  }
  arg1 = reinterpret_cast< _xmlID * >(argp1);result = (_xmlID *) ((arg1)->next);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlID, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlID_value_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlID *arg1 = (_xmlID *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlID_value_set" "', argument " "1"" of type '" "_xmlID *""'"); 
  }
  arg1 = reinterpret_cast< _xmlID * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlID_value_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->value = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlID_value_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlID *arg1 = (_xmlID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlID_value_get" "', argument " "1"" of type '" "_xmlID *""'"); 
  }
  arg1 = reinterpret_cast< _xmlID * >(argp1);result = (xmlChar *) ((arg1)->value);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlID_attr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlID *arg1 = (_xmlID *) 0 ;
  xmlAttrPtr arg2 = (xmlAttrPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlID_attr_set" "', argument " "1"" of type '" "_xmlID *""'"); 
  }
  arg1 = reinterpret_cast< _xmlID * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlID_attr_set', argument 2 of type 'xmlAttrPtr'"); 
  }
  arg2 = (xmlAttrPtr) arg20;if (arg1) (arg1)->attr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlID_attr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlID *arg1 = (_xmlID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlAttrPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlID_attr_get" "', argument " "1"" of type '" "_xmlID *""'"); 
  }
  arg1 = reinterpret_cast< _xmlID * >(argp1);result = (xmlAttrPtr) ((arg1)->attr);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlAttr);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlID_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlID *arg1 = (_xmlID *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlID_name_set" "', argument " "1"" of type '" "_xmlID *""'"); 
  }
  arg1 = reinterpret_cast< _xmlID * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlID_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->name = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlID_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlID *arg1 = (_xmlID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlID_name_get" "', argument " "1"" of type '" "_xmlID *""'"); 
  }
  arg1 = reinterpret_cast< _xmlID * >(argp1);result = (xmlChar *) ((arg1)->name);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlID_lineno_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlID *arg1 = (_xmlID *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlID_lineno_set" "', argument " "1"" of type '" "_xmlID *""'"); 
  }
  arg1 = reinterpret_cast< _xmlID * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlID_lineno_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->lineno = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlID_lineno_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlID *arg1 = (_xmlID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlID_lineno_get" "', argument " "1"" of type '" "_xmlID *""'"); 
  }
  arg1 = reinterpret_cast< _xmlID * >(argp1);result = (int) ((arg1)->lineno);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlID_doc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlID *arg1 = (_xmlID *) 0 ;
  _xmlDoc *arg2 = (_xmlDoc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlID_doc_set" "', argument " "1"" of type '" "_xmlID *""'"); 
  }
  arg1 = reinterpret_cast< _xmlID * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlID_doc_set', argument 2 of type '_xmlDoc *'"); 
  }
  arg2 = (_xmlDoc *) arg20;if (arg1) (arg1)->doc = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlID_doc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlID *arg1 = (_xmlID *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlDoc *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlID, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlID_doc_get" "', argument " "1"" of type '" "_xmlID *""'"); 
  }
  arg1 = reinterpret_cast< _xmlID * >(argp1);result = (_xmlDoc *) ((arg1)->doc);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlID(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlID *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlID.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlID.");
  result = (_xmlID *)new _xmlID();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlID, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlID(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlID * arg1 = (_xmlID *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlRef_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlRef *arg1 = (_xmlRef *) 0 ;
  _xmlRef *arg2 = (_xmlRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlRef_next_set" "', argument " "1"" of type '" "_xmlRef *""'"); 
  }
  arg1 = reinterpret_cast< _xmlRef * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlRef, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlRef_next_set" "', argument " "2"" of type '" "_xmlRef *""'"); 
  }
  arg2 = reinterpret_cast< _xmlRef * >(argp2);if (arg1) (arg1)->next = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlRef_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlRef *arg1 = (_xmlRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlRef *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlRef_next_get" "', argument " "1"" of type '" "_xmlRef *""'"); 
  }
  arg1 = reinterpret_cast< _xmlRef * >(argp1);result = (_xmlRef *) ((arg1)->next);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlRef, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlRef_value_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlRef *arg1 = (_xmlRef *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlRef_value_set" "', argument " "1"" of type '" "_xmlRef *""'"); 
  }
  arg1 = reinterpret_cast< _xmlRef * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlRef_value_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->value = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlRef_value_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlRef *arg1 = (_xmlRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlRef_value_get" "', argument " "1"" of type '" "_xmlRef *""'"); 
  }
  arg1 = reinterpret_cast< _xmlRef * >(argp1);result = (xmlChar *) ((arg1)->value);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlRef_attr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlRef *arg1 = (_xmlRef *) 0 ;
  xmlAttrPtr arg2 = (xmlAttrPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlRef_attr_set" "', argument " "1"" of type '" "_xmlRef *""'"); 
  }
  arg1 = reinterpret_cast< _xmlRef * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlRef_attr_set', argument 2 of type 'xmlAttrPtr'"); 
  }
  arg2 = (xmlAttrPtr) arg20;if (arg1) (arg1)->attr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlRef_attr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlRef *arg1 = (_xmlRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlAttrPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlRef_attr_get" "', argument " "1"" of type '" "_xmlRef *""'"); 
  }
  arg1 = reinterpret_cast< _xmlRef * >(argp1);result = (xmlAttrPtr) ((arg1)->attr);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlAttr);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlRef_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlRef *arg1 = (_xmlRef *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlRef_name_set" "', argument " "1"" of type '" "_xmlRef *""'"); 
  }
  arg1 = reinterpret_cast< _xmlRef * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlRef_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->name = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlRef_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlRef *arg1 = (_xmlRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlRef_name_get" "', argument " "1"" of type '" "_xmlRef *""'"); 
  }
  arg1 = reinterpret_cast< _xmlRef * >(argp1);result = (xmlChar *) ((arg1)->name);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlRef_lineno_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlRef *arg1 = (_xmlRef *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlRef_lineno_set" "', argument " "1"" of type '" "_xmlRef *""'"); 
  }
  arg1 = reinterpret_cast< _xmlRef * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlRef_lineno_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->lineno = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlRef_lineno_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlRef *arg1 = (_xmlRef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlRef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlRef_lineno_get" "', argument " "1"" of type '" "_xmlRef *""'"); 
  }
  arg1 = reinterpret_cast< _xmlRef * >(argp1);result = (int) ((arg1)->lineno);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlRef(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlRef *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlRef.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlRef.");
  result = (_xmlRef *)new _xmlRef();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlRef, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlRef(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlRef * arg1 = (_xmlRef *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlNode__private_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode__private_set', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlNode__private_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);_xmlNode__private_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNode__private_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode__private_get', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);result = (int)_xmlNode__private_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNode_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  xmlElementType arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_type_set', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlNode_type_set" "', argument " "2"" of type '" "xmlElementType""'");
  } 
  arg2 = static_cast< xmlElementType >(val2);_xmlNode_type_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNode_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlElementType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_type_get', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);result = (xmlElementType)_xmlNode_type_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNode_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_name_set', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlNode_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlNode_name_set(arg1,(unsigned char const *)arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNode_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_name_get', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);result = (xmlChar *)_xmlNode_name_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNode_children_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_children_set', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlNode_children_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlNode_children_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNode_children_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_children_get', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);result = (_xmlNode *)_xmlNode_children_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNode_last_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_last_set', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlNode_last_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlNode_last_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNode_last_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_last_get', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);result = (_xmlNode *)_xmlNode_last_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNode_parent_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_parent_set', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlNode_parent_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlNode_parent_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNode_parent_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_parent_get', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);result = (_xmlNode *)_xmlNode_parent_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNode_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_next_set', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlNode_next_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlNode_next_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNode_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_next_get', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);result = (_xmlNode *)_xmlNode_next_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNode_prev_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_prev_set', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlNode_prev_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlNode_prev_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNode_prev_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_prev_get', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);result = (_xmlNode *)_xmlNode_prev_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNode_doc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  _xmlDoc *arg2 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_doc_set', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlNode_doc_set', argument 2 of type '_xmlDoc *'"); 
  }
  arg2 = (_xmlDoc *) arg20;_xmlNode_doc_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNode_doc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlDoc *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_doc_get', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);result = (_xmlDoc *)_xmlNode_doc_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNode_ns_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  xmlNs *arg2 = (xmlNs *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_ns_set', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlNode_ns_set', argument 2 of type 'xmlNs *'"); 
  }
  arg2 = (xmlNs *) arg20;_xmlNode_ns_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNode_ns_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlNs *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_ns_get', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);result = (xmlNs *)_xmlNode_ns_get(arg1);
  jsresult = createWrapNs(result, SWIGTYPE_p__xmlNs);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNode_content_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_content_set', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlNode_content_set" "', argument " "2"" of type '" "xmlChar *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlNode_content_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNode_content_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_content_get', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);result = (xmlChar *)_xmlNode_content_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNode_properties_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  _xmlAttr *arg2 = (_xmlAttr *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_properties_set', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlNode_properties_set', argument 2 of type '_xmlAttr *'"); 
  }
  arg2 = (_xmlAttr *) arg20;_xmlNode_properties_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNode_properties_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlAttr *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_properties_get', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);result = (_xmlAttr *)_xmlNode_properties_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlAttr);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNode_nsDef_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  xmlNs *arg2 = (xmlNs *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_nsDef_set', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlNode_nsDef_set', argument 2 of type 'xmlNs *'"); 
  }
  arg2 = (xmlNs *) arg20;_xmlNode_nsDef_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNode_nsDef_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlNs *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_nsDef_get', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);result = (xmlNs *)_xmlNode_nsDef_get(arg1);
  jsresult = createWrapNs(result, SWIGTYPE_p__xmlNs);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNode_psvi_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  void *arg2 = (void *) 0 ;
  int res1 ;
  void *arg10 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_psvi_set', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);arg2 = getSwigCObjectPtr(value);_xmlNode_psvi_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNode_psvi_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_psvi_get', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);result = (void *)_xmlNode_psvi_get(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNode_line_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  unsigned short arg2 ;
  int res1 ;
  void *arg10 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_line_set', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);ecode2 = SWIG_AsVal_unsigned_SS_short(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlNode_line_set" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);_xmlNode_line_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNode_line_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  unsigned short result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_line_get', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);result = (unsigned short)_xmlNode_line_get(arg1);
  jsresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNode_extra_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  unsigned short arg2 ;
  int res1 ;
  void *arg10 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_extra_set', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);ecode2 = SWIG_AsVal_unsigned_SS_short(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlNode_extra_set" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);_xmlNode_extra_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNode_extra_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNode *arg1 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  unsigned short result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlNode_extra_get', argument 1 of type '_xmlNode *'"); 
    }
  }
  
  arg1 = ((_xmlNode *) arg10);result = (unsigned short)_xmlNode_extra_get(arg1);
  jsresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}

SWIGINTERN void delete__xmlNode(_xmlNode *self){
        destroyWrap((xmlNode*)self);
    }

static void _wrap_delete__xmlNode(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlNode * arg1 = (_xmlNode *)proxy->swigCObject;
    delete__xmlNode(arg1);
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap_new__xmlNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlNode *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlNode.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlNode.");
  result = (_xmlNode *)new _xmlNode();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlNode, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_DOC_WELLFORMED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DOC_WELLFORMED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DOC_NSVALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DOC_NSVALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DOC_OLD10_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DOC_OLD10));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DOC_DTDVALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DOC_DTDVALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DOC_XINCLUDE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DOC_XINCLUDE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DOC_USERBUILT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DOC_USERBUILT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DOC_INTERNAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DOC_INTERNAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DOC_HTML_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DOC_HTML));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc__private_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc__private_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlDoc__private_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);_xmlDoc__private_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc__private_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc__private_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (int)_xmlDoc__private_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  xmlElementType arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_type_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlDoc_type_set" "', argument " "2"" of type '" "xmlElementType""'");
  } 
  arg2 = static_cast< xmlElementType >(val2);_xmlDoc_type_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlElementType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_type_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (xmlElementType)_xmlDoc_type_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_name_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlDoc_name_set" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }_xmlDoc_name_set(arg1,arg2);
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_name_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (char *)_xmlDoc_name_get(arg1);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_children_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_children_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlDoc_children_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlDoc_children_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_children_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_children_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (_xmlNode *)_xmlDoc_children_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_last_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_last_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlDoc_last_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlDoc_last_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_last_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_last_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (_xmlNode *)_xmlDoc_last_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_parent_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_parent_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlDoc_parent_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlDoc_parent_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_parent_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_parent_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (_xmlNode *)_xmlDoc_parent_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_next_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlDoc_next_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlDoc_next_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_next_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (_xmlNode *)_xmlDoc_next_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_prev_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_prev_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlDoc_prev_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlDoc_prev_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_prev_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_prev_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (_xmlNode *)_xmlDoc_prev_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_doc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  _xmlDoc *arg2 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_doc_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlDoc_doc_set', argument 2 of type '_xmlDoc *'"); 
  }
  arg2 = (_xmlDoc *) arg20;_xmlDoc_doc_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_doc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlDoc *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_doc_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (_xmlDoc *)_xmlDoc_doc_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_compression_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_compression_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlDoc_compression_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);_xmlDoc_compression_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_compression_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_compression_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (int)_xmlDoc_compression_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_standalone_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_standalone_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlDoc_standalone_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);_xmlDoc_standalone_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_standalone_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_standalone_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (int)_xmlDoc_standalone_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_intSubset_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  _xmlDtd *arg2 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_intSubset_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlDoc_intSubset_set', argument 2 of type '_xmlDtd *'"); 
  }
  arg2 = (_xmlDtd *) arg20;_xmlDoc_intSubset_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_intSubset_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlDtd *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_intSubset_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (_xmlDtd *)_xmlDoc_intSubset_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDtd);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_extSubset_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  _xmlDtd *arg2 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_extSubset_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlDoc_extSubset_set', argument 2 of type '_xmlDtd *'"); 
  }
  arg2 = (_xmlDtd *) arg20;_xmlDoc_extSubset_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_extSubset_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlDtd *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_extSubset_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (_xmlDtd *)_xmlDoc_extSubset_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDtd);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_oldNs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  _xmlNs *arg2 = (_xmlNs *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_oldNs_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlDoc_oldNs_set', argument 2 of type '_xmlNs *'"); 
  }
  arg2 = (_xmlNs *) arg20;_xmlDoc_oldNs_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_oldNs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNs *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_oldNs_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (_xmlNs *)_xmlDoc_oldNs_get(arg1);
  jsresult = createWrapNs(result, SWIGTYPE_p__xmlNs);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_version_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_version_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlDoc_version_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlDoc_version_set(arg1,(unsigned char const *)arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_version_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_version_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (xmlChar *)_xmlDoc_version_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_encoding_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_encoding_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlDoc_encoding_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlDoc_encoding_set(arg1,(unsigned char const *)arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_encoding_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_encoding_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (xmlChar *)_xmlDoc_encoding_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_ids_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  void *arg2 = (void *) 0 ;
  int res1 ;
  void *arg10 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_ids_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;arg2 = getSwigCObjectPtr(value);_xmlDoc_ids_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_ids_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_ids_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (void *)_xmlDoc_ids_get(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_refs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  void *arg2 = (void *) 0 ;
  int res1 ;
  void *arg10 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_refs_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;arg2 = getSwigCObjectPtr(value);_xmlDoc_refs_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_refs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_refs_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (void *)_xmlDoc_refs_get(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_URL_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_URL_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlDoc_URL_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlDoc_URL_set(arg1,(unsigned char const *)arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_URL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_URL_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (xmlChar *)_xmlDoc_URL_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_charset_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_charset_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlDoc_charset_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);_xmlDoc_charset_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_charset_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_charset_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (int)_xmlDoc_charset_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_dict_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  _xmlDict *arg2 = (_xmlDict *) 0 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_dict_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlDict, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlDoc_dict_set" "', argument " "2"" of type '" "_xmlDict *""'"); 
  }
  arg2 = reinterpret_cast< _xmlDict * >(argp2);_xmlDoc_dict_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_dict_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlDict *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_dict_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (_xmlDict *)_xmlDoc_dict_get(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlDict, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_psvi_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  void *arg2 = (void *) 0 ;
  int res1 ;
  void *arg10 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_psvi_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;arg2 = getSwigCObjectPtr(value);_xmlDoc_psvi_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_psvi_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_psvi_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (void *)_xmlDoc_psvi_get(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_parseFlags_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_parseFlags_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlDoc_parseFlags_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);_xmlDoc_parseFlags_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_parseFlags_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_parseFlags_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (int)_xmlDoc_parseFlags_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDoc_properties_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_properties_set', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlDoc_properties_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);_xmlDoc_properties_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDoc_properties_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDoc *arg1 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlDoc_properties_get', argument 1 of type '_xmlDoc *'"); 
  }
  arg1 = (_xmlDoc *) arg10;result = (int)_xmlDoc_properties_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}

SWIGINTERN void delete__xmlDoc(_xmlDoc *self){
        destroyWrap((xmlNode*)self);
    }

static void _wrap_delete__xmlDoc(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlDoc * arg1 = (_xmlDoc *)proxy->swigCObject;
    delete__xmlDoc(arg1);
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap_new__xmlDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlDoc *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlDoc.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlDoc.");
  result = (_xmlDoc *)new _xmlDoc();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlDoc, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap__xmlDOMWrapCtxt__private_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDOMWrapCtxt *arg1 = (_xmlDOMWrapCtxt *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlDOMWrapCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlDOMWrapCtxt__private_set" "', argument " "1"" of type '" "_xmlDOMWrapCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlDOMWrapCtxt * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->_private = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDOMWrapCtxt__private_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDOMWrapCtxt *arg1 = (_xmlDOMWrapCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlDOMWrapCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlDOMWrapCtxt__private_get" "', argument " "1"" of type '" "_xmlDOMWrapCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlDOMWrapCtxt * >(argp1);result = (void *) ((arg1)->_private);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDOMWrapCtxt_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDOMWrapCtxt *arg1 = (_xmlDOMWrapCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlDOMWrapCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlDOMWrapCtxt_type_set" "', argument " "1"" of type '" "_xmlDOMWrapCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlDOMWrapCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlDOMWrapCtxt_type_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->type = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDOMWrapCtxt_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDOMWrapCtxt *arg1 = (_xmlDOMWrapCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlDOMWrapCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlDOMWrapCtxt_type_get" "', argument " "1"" of type '" "_xmlDOMWrapCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlDOMWrapCtxt * >(argp1);result = (int) ((arg1)->type);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDOMWrapCtxt_namespaceMap_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDOMWrapCtxt *arg1 = (_xmlDOMWrapCtxt *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlDOMWrapCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlDOMWrapCtxt_namespaceMap_set" "', argument " "1"" of type '" "_xmlDOMWrapCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlDOMWrapCtxt * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->namespaceMap = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDOMWrapCtxt_namespaceMap_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDOMWrapCtxt *arg1 = (_xmlDOMWrapCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlDOMWrapCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlDOMWrapCtxt_namespaceMap_get" "', argument " "1"" of type '" "_xmlDOMWrapCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlDOMWrapCtxt * >(argp1);result = (void *) ((arg1)->namespaceMap);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlDOMWrapCtxt_getNsForNodeFunc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlDOMWrapCtxt *arg1 = (_xmlDOMWrapCtxt *) 0 ;
  xmlDOMWrapAcquireNsFunction arg2 = (xmlDOMWrapAcquireNsFunction) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlDOMWrapCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlDOMWrapCtxt_getNsForNodeFunc_set" "', argument " "1"" of type '" "_xmlDOMWrapCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlDOMWrapCtxt * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_xmlDOMWrapCtxtPtr_xmlNodePtr_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlNs);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlDOMWrapCtxt_getNsForNodeFunc_set" "', argument " "2"" of type '" "xmlDOMWrapAcquireNsFunction""'"); 
      }
    }
  }
  if (arg1) (arg1)->getNsForNodeFunc = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlDOMWrapCtxt_getNsForNodeFunc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlDOMWrapCtxt *arg1 = (_xmlDOMWrapCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlDOMWrapAcquireNsFunction result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlDOMWrapCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlDOMWrapCtxt_getNsForNodeFunc_get" "', argument " "1"" of type '" "_xmlDOMWrapCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlDOMWrapCtxt * >(argp1);result = (xmlDOMWrapAcquireNsFunction) ((arg1)->getNsForNodeFunc);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_xmlDOMWrapCtxtPtr_xmlNodePtr_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlNs);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlDOMWrapCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlDOMWrapCtxt *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlDOMWrapCtxt.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlDOMWrapCtxt.");
  result = (_xmlDOMWrapCtxt *)new _xmlDOMWrapCtxt();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlDOMWrapCtxt, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlDOMWrapCtxt(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlDOMWrapCtxt * arg1 = (_xmlDOMWrapCtxt *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap___xmlBufferAllocScheme(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferAllocationScheme *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlBufferAllocScheme.");
  
  result = (xmlBufferAllocationScheme *)__xmlBufferAllocScheme();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_xmlBufferAllocationScheme, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlDefaultBufferSize(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlDefaultBufferSize.");
  
  result = (int *)__xmlDefaultBufferSize();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlRegisterNodeDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRegisterNodeFunc *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlRegisterNodeDefaultValue.");
  
  result = (xmlRegisterNodeFunc *)__xmlRegisterNodeDefaultValue();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_f_p__xmlNode__void, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlDeregisterNodeDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDeregisterNodeFunc *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlDeregisterNodeDefaultValue.");
  
  result = (xmlDeregisterNodeFunc *)__xmlDeregisterNodeDefaultValue();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_f_p__xmlNode__void, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateNCName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateNCName.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateNCName" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlValidateNCName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlValidateNCName((unsigned char const *)arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateQName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateQName.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateQName" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlValidateQName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlValidateQName((unsigned char const *)arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateName.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateName" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlValidateName" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlValidateName((unsigned char const *)arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateNMToken(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateNMToken.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateNMToken" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlValidateNMToken" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlValidateNMToken((unsigned char const *)arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBuildQName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBuildQName.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBuildQName" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlBuildQName" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlBuildQName" "', argument " "3"" of type '" "xmlChar *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlBuildQName" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (xmlChar *)xmlBuildQName((unsigned char const *)arg1,(unsigned char const *)arg2,arg3,arg4);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSplitQName2(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSplitQName2.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSplitQName2" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSplitQName2" "', argument " "2"" of type '" "xmlChar **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);result = (xmlChar *)xmlSplitQName2((unsigned char const *)arg1,arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSplitQName3(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int *arg2 = (int *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSplitQName3.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSplitQName3" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSplitQName3" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);result = (xmlChar *)xmlSplitQName3((unsigned char const *)arg1,arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSetBufferAllocationScheme(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferAllocationScheme arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSetBufferAllocationScheme.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlSetBufferAllocationScheme" "', argument " "1"" of type '" "xmlBufferAllocationScheme""'");
  } 
  arg1 = static_cast< xmlBufferAllocationScheme >(val1);xmlSetBufferAllocationScheme(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetBufferAllocationScheme(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferAllocationScheme result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetBufferAllocationScheme.");
  
  result = (xmlBufferAllocationScheme)xmlGetBufferAllocationScheme();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferCreate(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferCreate.");
  
  result = (xmlBufferPtr)xmlBufferCreate();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlBuffer, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferCreateSize(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  xmlBufferPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferCreateSize.");
  
  ecode1 = SWIG_AsVal_size_t(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlBufferCreateSize" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);result = (xmlBufferPtr)xmlBufferCreateSize(SWIG_STD_MOVE(arg1));
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlBuffer, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferCreateStatic(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  size_t arg2 ;
  size_t val2 ;
  int ecode2 = 0 ;
  xmlBufferPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferCreateStatic.");
  
  arg1 = getSwigCObjectPtr(args[0]);ecode2 = SWIG_AsVal_size_t(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlBufferCreateStatic" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);result = (xmlBufferPtr)xmlBufferCreateStatic(arg1,SWIG_STD_MOVE(arg2));
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlBuffer, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferResize(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferResize.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufferResize" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlBufferResize" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);result = (int)xmlBufferResize(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferFree(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferFree.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufferFree" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);xmlBufferFree(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferDump(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  xmlBufferPtr arg2 = (xmlBufferPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferDump.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufferDump" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlBufferDump" "', argument " "2"" of type '" "xmlBufferPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlBufferPtr >(argp2);result = (int)xmlBufferDump(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferAdd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferAdd.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufferAdd" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlBufferAdd" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlBufferAdd" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlBufferAdd(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferAddHead(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferAddHead.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufferAddHead" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlBufferAddHead" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlBufferAddHead" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlBufferAddHead(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferCat(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferCat.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufferCat" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlBufferCat" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlBufferCat(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferCCat(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferCCat.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufferCCat" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlBufferCCat" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (int)xmlBufferCCat(arg1,(char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferShrink(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferShrink.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufferShrink" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlBufferShrink" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);result = (int)xmlBufferShrink(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferGrow(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferGrow.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufferGrow" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlBufferGrow" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);result = (int)xmlBufferGrow(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferEmpty(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferEmpty.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufferEmpty" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);xmlBufferEmpty(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBuffer *arg1 = (xmlBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferContent.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufferContent" "', argument " "1"" of type '" "xmlBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< xmlBuffer * >(argp1);result = (xmlChar *)xmlBufferContent((_xmlBuffer const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferDetach(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferDetach.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufferDetach" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);result = (xmlChar *)xmlBufferDetach(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferSetAllocationScheme(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlBufferAllocationScheme arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferSetAllocationScheme.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufferSetAllocationScheme" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlBufferSetAllocationScheme" "', argument " "2"" of type '" "xmlBufferAllocationScheme""'");
  } 
  arg2 = static_cast< xmlBufferAllocationScheme >(val2);xmlBufferSetAllocationScheme(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferLength(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBuffer *arg1 = (xmlBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferLength.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufferLength" "', argument " "1"" of type '" "xmlBuffer const *""'"); 
  }
  arg1 = reinterpret_cast< xmlBuffer * >(argp1);result = (int)xmlBufferLength((_xmlBuffer const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCreateIntSubset(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  xmlDtdPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCreateIntSubset.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlCreateIntSubset', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCreateIntSubset" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlCreateIntSubset" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlCreateIntSubset" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (xmlDtdPtr)xmlCreateIntSubset(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDtd);
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewDtd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  xmlDtdPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewDtd.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewDtd', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewDtd" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlNewDtd" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlNewDtd" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (xmlDtdPtr)xmlNewDtd(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDtd);
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetIntSubset(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDoc *arg1 = (xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlDtdPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetIntSubset.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetIntSubset', argument 1 of type 'xmlDoc const *'"); 
  }
  arg1 = (xmlDoc *) arg10;result = (xmlDtdPtr)xmlGetIntSubset((_xmlDoc const *)arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDtd);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeDtd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDtdPtr arg1 = (xmlDtdPtr) 0 ;
  int res1 ;
  void *arg10 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeDtd.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlFreeDtd', argument 1 of type 'xmlDtdPtr'"); 
  }
  arg1 = (xmlDtdPtr) arg10;xmlFreeDtd(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewNs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlNsPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewNs.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewNs', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewNs" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlNewNs" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlNsPtr)xmlNewNs(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = createWrapNs(result, SWIGTYPE_p__xmlNs);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeNs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNsPtr arg1 = (xmlNsPtr) 0 ;
  int res1 ;
  void *arg10 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeNs.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlFreeNs', argument 1 of type 'xmlNsPtr'"); 
  }
  arg1 = (xmlNsPtr) arg10;xmlFreeNs(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeNsList(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNsPtr arg1 = (xmlNsPtr) 0 ;
  int res1 ;
  void *arg10 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeNsList.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlFreeNsList', argument 1 of type 'xmlNsPtr'"); 
  }
  arg1 = (xmlNsPtr) arg10;xmlFreeNsList(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewDoc.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewDoc" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlDocPtr)xmlNewDoc((unsigned char const *)arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  int res1 ;
  void *arg10 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeDoc.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlFreeDoc', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;xmlFreeDoc(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewDocProp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlAttrPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewDocProp.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewDocProp', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewDocProp" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlNewDocProp" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlAttrPtr)xmlNewDocProp(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlAttr);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewProp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlAttrPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewProp.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewProp', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewProp" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlNewProp" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlAttrPtr)xmlNewProp(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlAttr);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewNsProp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlNsPtr arg2 = (xmlNsPtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  xmlAttrPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewNsProp.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewNsProp', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlNewNsProp', argument 2 of type 'xmlNsPtr'"); 
  }
  arg2 = (xmlNsPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlNewNsProp" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlNewNsProp" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (xmlAttrPtr)xmlNewNsProp(arg1,arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlAttr);
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewNsPropEatName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlNsPtr arg2 = (xmlNsPtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  xmlAttrPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewNsPropEatName.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewNsPropEatName', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlNewNsPropEatName', argument 2 of type 'xmlNsPtr'"); 
  }
  arg2 = (xmlNsPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlNewNsPropEatName" "', argument " "3"" of type '" "xmlChar *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlNewNsPropEatName" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (xmlAttrPtr)xmlNewNsPropEatName(arg1,arg2,arg3,(unsigned char const *)arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlAttr);
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreePropList(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAttrPtr arg1 = (xmlAttrPtr) 0 ;
  int res1 ;
  void *arg10 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreePropList.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlFreePropList', argument 1 of type 'xmlAttrPtr'"); 
  }
  arg1 = (xmlAttrPtr) arg10;xmlFreePropList(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeProp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAttrPtr arg1 = (xmlAttrPtr) 0 ;
  int res1 ;
  void *arg10 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeProp.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlFreeProp', argument 1 of type 'xmlAttrPtr'"); 
  }
  arg1 = (xmlAttrPtr) arg10;xmlFreeProp(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyProp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlAttrPtr arg2 = (xmlAttrPtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  xmlAttrPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyProp.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlCopyProp', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlCopyProp', argument 2 of type 'xmlAttrPtr'"); 
  }
  arg2 = (xmlAttrPtr) arg20;result = (xmlAttrPtr)xmlCopyProp(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlAttr);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyPropList(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlAttrPtr arg2 = (xmlAttrPtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  xmlAttrPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyPropList.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlCopyPropList', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlCopyPropList', argument 2 of type 'xmlAttrPtr'"); 
  }
  arg2 = (xmlAttrPtr) arg20;result = (xmlAttrPtr)xmlCopyPropList(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlAttr);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyDtd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDtdPtr arg1 = (xmlDtdPtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlDtdPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyDtd.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlCopyDtd', argument 1 of type 'xmlDtdPtr'"); 
  }
  arg1 = (xmlDtdPtr) arg10;result = (xmlDtdPtr)xmlCopyDtd(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDtd);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyDoc.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlCopyDoc', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlCopyDoc" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlDocPtr)xmlCopyDoc(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewDocNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlNsPtr arg2 = (xmlNsPtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewDocNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewDocNode', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlNewDocNode', argument 2 of type 'xmlNsPtr'"); 
  }
  arg2 = (xmlNsPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlNewDocNode" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlNewDocNode" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (xmlNodePtr)xmlNewDocNode(arg1,arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewDocNodeEatName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlNsPtr arg2 = (xmlNsPtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewDocNodeEatName.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewDocNodeEatName', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlNewDocNodeEatName', argument 2 of type 'xmlNsPtr'"); 
  }
  arg2 = (xmlNsPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlNewDocNodeEatName" "', argument " "3"" of type '" "xmlChar *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlNewDocNodeEatName" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (xmlNodePtr)xmlNewDocNodeEatName(arg1,arg2,arg3,(unsigned char const *)arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNsPtr arg1 = (xmlNsPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewNode', argument 1 of type 'xmlNsPtr'"); 
  }
  arg1 = (xmlNsPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewNode" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlNodePtr)xmlNewNode(arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewNodeEatName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNsPtr arg1 = (xmlNsPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewNodeEatName.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewNodeEatName', argument 1 of type 'xmlNsPtr'"); 
  }
  arg1 = (xmlNsPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewNodeEatName" "', argument " "2"" of type '" "xmlChar *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlNodePtr)xmlNewNodeEatName(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewChild(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlNsPtr arg2 = (xmlNsPtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewChild.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewChild', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlNewChild', argument 2 of type 'xmlNsPtr'"); 
  }
  arg2 = (xmlNsPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlNewChild" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlNewChild" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (xmlNodePtr)xmlNewChild(arg1,arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewDocText(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDoc *arg1 = (xmlDoc *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewDocText.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewDocText', argument 1 of type 'xmlDoc const *'"); 
  }
  arg1 = (xmlDoc *) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewDocText" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlNodePtr)xmlNewDocText((_xmlDoc const *)arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewText(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewText.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewText" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlNodePtr)xmlNewText((unsigned char const *)arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewDocPI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewDocPI.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewDocPI', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewDocPI" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlNewDocPI" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlNodePtr)xmlNewDocPI(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewPI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewPI.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewPI" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewPI" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlNodePtr)xmlNewPI((unsigned char const *)arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewDocTextLen(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewDocTextLen.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewDocTextLen', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewDocTextLen" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlNewDocTextLen" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlNodePtr)xmlNewDocTextLen(arg1,(unsigned char const *)arg2,arg3);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewTextLen(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewTextLen.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewTextLen" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlNewTextLen" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlNodePtr)xmlNewTextLen((unsigned char const *)arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewDocComment(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewDocComment.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewDocComment', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewDocComment" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlNodePtr)xmlNewDocComment(arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewComment(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewComment.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewComment" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlNodePtr)xmlNewComment((unsigned char const *)arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewCDataBlock(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewCDataBlock.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewCDataBlock', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewCDataBlock" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlNewCDataBlock" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlNodePtr)xmlNewCDataBlock(arg1,(unsigned char const *)arg2,arg3);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewCharRef(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewCharRef.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewCharRef', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewCharRef" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlNodePtr)xmlNewCharRef(arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewReference(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDoc *arg1 = (xmlDoc *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewReference.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewReference', argument 1 of type 'xmlDoc const *'"); 
  }
  arg1 = (xmlDoc *) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewReference" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlNodePtr)xmlNewReference((_xmlDoc const *)arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlCopyNode', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlCopyNode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlNodePtr)xmlCopyNode(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDocCopyNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  int arg3 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDocCopyNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlDocCopyNode', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlDocCopyNode', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlDocCopyNode" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlNodePtr)xmlDocCopyNode(arg1,arg2,arg3);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDocCopyNodeList(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDocCopyNodeList.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlDocCopyNodeList', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlDocCopyNodeList', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlDocCopyNodeList(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyNodeList(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlNodePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyNodeList.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlCopyNodeList', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);result = (xmlNodePtr)xmlCopyNodeList(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewTextChild(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlNsPtr arg2 = (xmlNsPtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewTextChild.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewTextChild', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlNewTextChild', argument 2 of type 'xmlNsPtr'"); 
  }
  arg2 = (xmlNsPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlNewTextChild" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlNewTextChild" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (xmlNodePtr)xmlNewTextChild(arg1,arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewDocRawNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlNsPtr arg2 = (xmlNsPtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewDocRawNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewDocRawNode', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlNewDocRawNode', argument 2 of type 'xmlNsPtr'"); 
  }
  arg2 = (xmlNsPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlNewDocRawNode" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlNewDocRawNode" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (xmlNodePtr)xmlNewDocRawNode(arg1,arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewDocFragment(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlNodePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewDocFragment.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewDocFragment', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;result = (xmlNodePtr)xmlNewDocFragment(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetLineNo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNode *arg1 = (xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  long result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetLineNo.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetLineNo', argument 1 of type 'xmlNode const *'"); 
    }
  }
  
  arg1 = ((xmlNode *) arg10);result = (long)xmlGetLineNo((_xmlNode const *)arg1);
  jsresult = SWIG_From_long(static_cast< long >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetNodePath(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNode *arg1 = (xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetNodePath.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetNodePath', argument 1 of type 'xmlNode const *'"); 
    }
  }
  
  arg1 = ((xmlNode *) arg10);result = (xmlChar *)xmlGetNodePath((_xmlNode const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDocGetRootElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDoc *arg1 = (xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlNodePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDocGetRootElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlDocGetRootElement', argument 1 of type 'xmlDoc const *'"); 
  }
  arg1 = (xmlDoc *) arg10;result = (xmlNodePtr)xmlDocGetRootElement((_xmlDoc const *)arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetLastChild(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNode *arg1 = (xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlNodePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetLastChild.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetLastChild', argument 1 of type 'xmlNode const *'"); 
    }
  }
  
  arg1 = ((xmlNode *) arg10);result = (xmlNodePtr)xmlGetLastChild((_xmlNode const *)arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeIsText(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNode *arg1 = (xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeIsText.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNodeIsText', argument 1 of type 'xmlNode const *'"); 
    }
  }
  
  arg1 = ((xmlNode *) arg10);result = (int)xmlNodeIsText((_xmlNode const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlIsBlankNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNode *arg1 = (xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlIsBlankNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlIsBlankNode', argument 1 of type 'xmlNode const *'"); 
    }
  }
  
  arg1 = ((xmlNode *) arg10);result = (int)xmlIsBlankNode((_xmlNode const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDocSetRootElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDocSetRootElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlDocSetRootElement', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlDocSetRootElement', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlDocSetRootElement(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeSetName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeSetName.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNodeSetName', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNodeSetName" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }xmlNodeSetName(arg1,(unsigned char const *)arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAddChild(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAddChild.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlAddChild', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlAddChild', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlAddChild(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAddChildList(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAddChildList.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlAddChildList', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlAddChildList', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlAddChildList(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReplaceNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReplaceNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlReplaceNode', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlReplaceNode', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlReplaceNode(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAddPrevSibling(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAddPrevSibling.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlAddPrevSibling', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlAddPrevSibling', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlAddPrevSibling(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAddSibling(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAddSibling.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlAddSibling', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlAddSibling', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlAddSibling(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAddNextSibling(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAddNextSibling.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlAddNextSibling', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlAddNextSibling', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlAddNextSibling(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextMerge(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextMerge.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlTextMerge', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlTextMerge', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlTextMerge(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextConcat(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextConcat.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlTextConcat', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextConcat" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlTextConcat" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlTextConcat(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeNodeList(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeNodeList.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlFreeNodeList', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);xmlFreeNodeList(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlFreeNode', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);xmlFreeNode(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSetTreeDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSetTreeDoc.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlSetTreeDoc', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlSetTreeDoc', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;result = (int)xmlSetTreeDoc(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSetListDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSetListDoc.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlSetListDoc', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlSetListDoc', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;result = (int)xmlSetListDoc(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSearchNs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlNsPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSearchNs.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlSearchNs', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlSearchNs', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSearchNs" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlNsPtr)xmlSearchNs(arg1,arg2,(unsigned char const *)arg3);
  jsresult = createWrapNs(result, SWIGTYPE_p__xmlNs);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSearchNsByHref(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlNsPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSearchNsByHref.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlSearchNsByHref', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlSearchNsByHref', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSearchNsByHref" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlNsPtr)xmlSearchNsByHref(arg1,arg2,(unsigned char const *)arg3);
  jsresult = createWrapNs(result, SWIGTYPE_p__xmlNs);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetNsListSafe(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDoc *arg1 = (xmlDoc *) 0 ;
  xmlNode *arg2 = (xmlNode *) 0 ;
  xmlNsPtr **arg3 = (xmlNsPtr **) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetNsListSafe.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetNsListSafe', argument 1 of type 'xmlDoc const *'"); 
  }
  arg1 = (xmlDoc *) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlGetNsListSafe', argument 2 of type 'xmlNode const *'"); 
    }
  }
  
  arg2 = ((xmlNode *) arg20);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlGetNsListSafe" "', argument " "3"" of type '" "xmlNsPtr **""'"); 
  }
  arg3 = reinterpret_cast< xmlNsPtr ** >(argp3);result = (int)xmlGetNsListSafe((_xmlDoc const *)arg1,(_xmlNode const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetNsList(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDoc *arg1 = (xmlDoc *) 0 ;
  xmlNode *arg2 = (xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  xmlNsPtr *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetNsList.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetNsList', argument 1 of type 'xmlDoc const *'"); 
  }
  arg1 = (xmlDoc *) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlGetNsList', argument 2 of type 'xmlNode const *'"); 
    }
  }
  
  arg2 = ((xmlNode *) arg20);result = (xmlNsPtr *)xmlGetNsList((_xmlDoc const *)arg1,(_xmlNode const *)arg2);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && result[index] != NULL; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result[index]), SWIGTYPE_p__xmlNs, 0 |  0 ));
      SWIGV8_AppendOutput(jsresult, createWrap(((xmlNode*) result[index]), SWIGTYPE_p__xmlNs));
    }
    
    xmlFree(result);
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSetNs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlNsPtr arg2 = (xmlNsPtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSetNs.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlSetNs', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlSetNs', argument 2 of type 'xmlNsPtr'"); 
  }
  arg2 = (xmlNsPtr) arg20;xmlSetNs(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyNamespace(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNsPtr arg1 = (xmlNsPtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlNsPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyNamespace.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlCopyNamespace', argument 1 of type 'xmlNsPtr'"); 
  }
  arg1 = (xmlNsPtr) arg10;result = (xmlNsPtr)xmlCopyNamespace(arg1);
  jsresult = createWrapNs(result, SWIGTYPE_p__xmlNs);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyNamespaceList(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNsPtr arg1 = (xmlNsPtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlNsPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyNamespaceList.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlCopyNamespaceList', argument 1 of type 'xmlNsPtr'"); 
  }
  arg1 = (xmlNsPtr) arg10;result = (xmlNsPtr)xmlCopyNamespaceList(arg1);
  jsresult = createWrapNs(result, SWIGTYPE_p__xmlNs);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSetProp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlAttrPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSetProp.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlSetProp', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSetProp" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSetProp" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlAttrPtr)xmlSetProp(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlAttr);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSetNsProp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlNsPtr arg2 = (xmlNsPtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  xmlAttrPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSetNsProp.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlSetNsProp', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlSetNsProp', argument 2 of type 'xmlNsPtr'"); 
  }
  arg2 = (xmlNsPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSetNsProp" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSetNsProp" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (xmlAttrPtr)xmlSetNsProp(arg1,arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlAttr);
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeGetAttrValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNode *arg1 = (xmlNode *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar **arg4 = (xmlChar **) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeGetAttrValue.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNodeGetAttrValue', argument 1 of type 'xmlNode const *'"); 
    }
  }
  
  arg1 = ((xmlNode *) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNodeGetAttrValue" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlNodeGetAttrValue" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlNodeGetAttrValue" "', argument " "4"" of type '" "xmlChar **""'"); 
  }
  arg4 = reinterpret_cast< xmlChar ** >(argp4);result = (int)xmlNodeGetAttrValue((_xmlNode const *)arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetNoNsProp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNode *arg1 = (xmlNode *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetNoNsProp.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetNoNsProp', argument 1 of type 'xmlNode const *'"); 
    }
  }
  
  arg1 = ((xmlNode *) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlGetNoNsProp" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlGetNoNsProp((_xmlNode const *)arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetProp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNode *arg1 = (xmlNode *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetProp.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetProp', argument 1 of type 'xmlNode const *'"); 
    }
  }
  
  arg1 = ((xmlNode *) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlGetProp" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlGetProp((_xmlNode const *)arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHasProp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNode *arg1 = (xmlNode *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlAttrPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHasProp.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlHasProp', argument 1 of type 'xmlNode const *'"); 
    }
  }
  
  arg1 = ((xmlNode *) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHasProp" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlAttrPtr)xmlHasProp((_xmlNode const *)arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlAttr);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHasNsProp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNode *arg1 = (xmlNode *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlAttrPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHasNsProp.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlHasNsProp', argument 1 of type 'xmlNode const *'"); 
    }
  }
  
  arg1 = ((xmlNode *) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHasNsProp" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlHasNsProp" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlAttrPtr)xmlHasNsProp((_xmlNode const *)arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlAttr);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetNsProp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNode *arg1 = (xmlNode *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetNsProp.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetNsProp', argument 1 of type 'xmlNode const *'"); 
    }
  }
  
  arg1 = ((xmlNode *) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlGetNsProp" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlGetNsProp" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlChar *)xmlGetNsProp((_xmlNode const *)arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStringGetNodeList(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDoc *arg1 = (xmlDoc *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStringGetNodeList.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlStringGetNodeList', argument 1 of type 'xmlDoc const *'"); 
  }
  arg1 = (xmlDoc *) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStringGetNodeList" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlNodePtr)xmlStringGetNodeList((_xmlDoc const *)arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStringLenGetNodeList(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDoc *arg1 = (xmlDoc *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStringLenGetNodeList.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlStringLenGetNodeList', argument 1 of type 'xmlDoc const *'"); 
  }
  arg1 = (xmlDoc *) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStringLenGetNodeList" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlStringLenGetNodeList" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlNodePtr)xmlStringLenGetNodeList((_xmlDoc const *)arg1,(unsigned char const *)arg2,arg3);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeListGetString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlNode *arg2 = (xmlNode *) 0 ;
  int arg3 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeListGetString.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNodeListGetString', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlNodeListGetString', argument 2 of type 'xmlNode const *'"); 
    }
  }
  
  arg2 = ((xmlNode *) arg20);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlNodeListGetString" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlChar *)xmlNodeListGetString(arg1,(_xmlNode const *)arg2,arg3);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeListGetRawString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDoc *arg1 = (xmlDoc *) 0 ;
  xmlNode *arg2 = (xmlNode *) 0 ;
  int arg3 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeListGetRawString.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNodeListGetRawString', argument 1 of type 'xmlDoc const *'"); 
  }
  arg1 = (xmlDoc *) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlNodeListGetRawString', argument 2 of type 'xmlNode const *'"); 
    }
  }
  
  arg2 = ((xmlNode *) arg20);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlNodeListGetRawString" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlChar *)xmlNodeListGetRawString((_xmlDoc const *)arg1,(_xmlNode const *)arg2,arg3);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeSetContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeSetContent.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNodeSetContent', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNodeSetContent" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlNodeSetContent(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeSetContentLen(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeSetContentLen.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNodeSetContentLen', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNodeSetContentLen" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlNodeSetContentLen" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlNodeSetContentLen(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeAddContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeAddContent.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNodeAddContent', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNodeAddContent" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlNodeAddContent(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeAddContentLen(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeAddContentLen.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNodeAddContentLen', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNodeAddContentLen" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlNodeAddContentLen" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlNodeAddContentLen(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeGetContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNode *arg1 = (xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeGetContent.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNodeGetContent', argument 1 of type 'xmlNode const *'"); 
    }
  }
  
  arg1 = ((xmlNode *) arg10);result = (xmlChar *)xmlNodeGetContent((_xmlNode const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeBufGetContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlNode *arg2 = (xmlNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeBufGetContent.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNodeBufGetContent" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlNodeBufGetContent', argument 2 of type 'xmlNode const *'"); 
    }
  }
  
  arg2 = ((xmlNode *) arg20);result = (int)xmlNodeBufGetContent(arg1,(_xmlNode const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufGetNodeContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufPtr arg1 = (xmlBufPtr) 0 ;
  xmlNode *arg2 = (xmlNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufGetNodeContent.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufGetNodeContent" "', argument " "1"" of type '" "xmlBufPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlBufGetNodeContent', argument 2 of type 'xmlNode const *'"); 
    }
  }
  
  arg2 = ((xmlNode *) arg20);result = (int)xmlBufGetNodeContent(arg1,(_xmlNode const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeGetLang(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNode *arg1 = (xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeGetLang.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNodeGetLang', argument 1 of type 'xmlNode const *'"); 
    }
  }
  
  arg1 = ((xmlNode *) arg10);result = (xmlChar *)xmlNodeGetLang((_xmlNode const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeGetSpacePreserve(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNode *arg1 = (xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeGetSpacePreserve.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNodeGetSpacePreserve', argument 1 of type 'xmlNode const *'"); 
    }
  }
  
  arg1 = ((xmlNode *) arg10);result = (int)xmlNodeGetSpacePreserve((_xmlNode const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeSetLang(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeSetLang.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNodeSetLang', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNodeSetLang" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlNodeSetLang(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeSetSpacePreserve(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeSetSpacePreserve.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNodeSetSpacePreserve', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlNodeSetSpacePreserve" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlNodeSetSpacePreserve(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeGetBaseSafe(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDoc *arg1 = (xmlDoc *) 0 ;
  xmlNode *arg2 = (xmlNode *) 0 ;
  xmlChar **arg3 = (xmlChar **) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeGetBaseSafe.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNodeGetBaseSafe', argument 1 of type 'xmlDoc const *'"); 
  }
  arg1 = (xmlDoc *) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlNodeGetBaseSafe', argument 2 of type 'xmlNode const *'"); 
    }
  }
  
  arg2 = ((xmlNode *) arg20);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlNodeGetBaseSafe" "', argument " "3"" of type '" "xmlChar **""'"); 
  }
  arg3 = reinterpret_cast< xmlChar ** >(argp3);result = (int)xmlNodeGetBaseSafe((_xmlDoc const *)arg1,(_xmlNode const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeGetBase(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDoc *arg1 = (xmlDoc *) 0 ;
  xmlNode *arg2 = (xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeGetBase.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNodeGetBase', argument 1 of type 'xmlDoc const *'"); 
  }
  arg1 = (xmlDoc *) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlNodeGetBase', argument 2 of type 'xmlNode const *'"); 
    }
  }
  
  arg2 = ((xmlNode *) arg20);result = (xmlChar *)xmlNodeGetBase((_xmlDoc const *)arg1,(_xmlNode const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeSetBase(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeSetBase.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNodeSetBase', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNodeSetBase" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlNodeSetBase(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRemoveProp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAttrPtr arg1 = (xmlAttrPtr) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRemoveProp.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlRemoveProp', argument 1 of type 'xmlAttrPtr'"); 
  }
  arg1 = (xmlAttrPtr) arg10;result = (int)xmlRemoveProp(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUnsetNsProp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlNsPtr arg2 = (xmlNsPtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUnsetNsProp.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlUnsetNsProp', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlUnsetNsProp', argument 2 of type 'xmlNsPtr'"); 
  }
  arg2 = (xmlNsPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlUnsetNsProp" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (int)xmlUnsetNsProp(arg1,arg2,(unsigned char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUnsetProp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUnsetProp.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlUnsetProp', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlUnsetProp" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlUnsetProp(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferWriteCHAR(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferWriteCHAR.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufferWriteCHAR" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlBufferWriteCHAR" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }xmlBufferWriteCHAR(arg1,(unsigned char const *)arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferWriteChar(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferWriteChar.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufferWriteChar" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlBufferWriteChar" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }xmlBufferWriteChar(arg1,(char const *)arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufferWriteQuotedString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufferWriteQuotedString.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufferWriteQuotedString" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlBufferWriteQuotedString" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }xmlBufferWriteQuotedString(arg1,(unsigned char const *)arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAttrSerializeTxtContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlAttrPtr arg3 = (xmlAttrPtr) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAttrSerializeTxtContent.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAttrSerializeTxtContent" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlAttrSerializeTxtContent', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlAttrSerializeTxtContent', argument 3 of type 'xmlAttrPtr'"); 
  }
  arg3 = (xmlAttrPtr) arg30;if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlAttrSerializeTxtContent" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }xmlAttrSerializeTxtContent(arg1,arg2,arg3,(unsigned char const *)arg4);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReconciliateNs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReconciliateNs.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlReconciliateNs', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlReconciliateNs', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (int)xmlReconciliateNs(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDocDumpFormatMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  int *arg3 = (int *) 0 ;
  int arg4 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDocDumpFormatMemory.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlDocDumpFormatMemory', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlDocDumpFormatMemory" "', argument " "2"" of type '" "xmlChar **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlDocDumpFormatMemory" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlDocDumpFormatMemory" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);xmlDocDumpFormatMemory(arg1,arg2,arg3,arg4);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDocDumpMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  int *arg3 = (int *) 0 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDocDumpMemory.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlDocDumpMemory', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlDocDumpMemory" "', argument " "2"" of type '" "xmlChar **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlDocDumpMemory" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);xmlDocDumpMemory(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDocDumpMemoryEnc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  int *arg3 = (int *) 0 ;
  char *arg4 = (char *) 0 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDocDumpMemoryEnc.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlDocDumpMemoryEnc', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlDocDumpMemoryEnc" "', argument " "2"" of type '" "xmlChar **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlDocDumpMemoryEnc" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlDocDumpMemoryEnc" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }xmlDocDumpMemoryEnc(arg1,arg2,arg3,(char const *)arg4);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  // free(arg4);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDocDumpFormatMemoryEnc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  int *arg3 = (int *) 0 ;
  char *arg4 = (char *) 0 ;
  int arg5 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDocDumpFormatMemoryEnc.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlDocDumpFormatMemoryEnc', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlDocDumpFormatMemoryEnc" "', argument " "2"" of type '" "xmlChar **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlDocDumpFormatMemoryEnc" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlDocDumpFormatMemoryEnc" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlDocDumpFormatMemoryEnc" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);xmlDocDumpFormatMemoryEnc(arg1,arg2,arg3,(char const *)arg4,arg5);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  // free(arg4);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDocFormatDump(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDocFormatDump.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDocFormatDump" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlDocFormatDump', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlDocFormatDump" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlDocFormatDump(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDocDump(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDocDump.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDocDump" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlDocDump', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;result = (int)xmlDocDump(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlElemDump(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlElemDump.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlElemDump" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlElemDump', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlElemDump', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);xmlElemDump(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSaveFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveFile.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSaveFile" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlSaveFile', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;result = (int)xmlSaveFile((char const *)arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  // free(arg1);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSaveFormatFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  void *arg20 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveFormatFile.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSaveFormatFile" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlSaveFormatFile', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSaveFormatFile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlSaveFormatFile((char const *)arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  // free(arg1);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBufNodeDump(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufPtr arg1 = (xmlBufPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  size_t result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBufNodeDump.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuf, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBufNodeDump" "', argument " "1"" of type '" "xmlBufPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlBufNodeDump', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlBufNodeDump', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlBufNodeDump" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlBufNodeDump" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);result = xmlBufNodeDump(arg1,arg2,arg3,arg4,arg5);
  jsresult = SWIG_From_size_t(static_cast< size_t >(result));
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeDump(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeDump.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNodeDump" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlNodeDump', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlNodeDump', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlNodeDump" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlNodeDump" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);result = (int)xmlNodeDump(arg1,arg2,arg3,arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSaveFileTo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferPtr arg1 = (xmlOutputBufferPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveFileTo.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSaveFileTo" "', argument " "1"" of type '" "xmlOutputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlOutputBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlSaveFileTo', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSaveFileTo" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }result = (int)xmlSaveFileTo(arg1,arg2,(char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  // free(arg3);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSaveFormatFileTo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferPtr arg1 = (xmlOutputBufferPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveFormatFileTo.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSaveFormatFileTo" "', argument " "1"" of type '" "xmlOutputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlOutputBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlSaveFormatFileTo', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSaveFormatFileTo" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlSaveFormatFileTo" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (int)xmlSaveFormatFileTo(arg1,arg2,(char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  // free(arg3);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNodeDumpOutput(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferPtr arg1 = (xmlOutputBufferPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  int arg4 ;
  int arg5 ;
  char *arg6 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  size_t size6 = 0 ;
  int alloc6 = 0 ;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNodeDumpOutput.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNodeDumpOutput" "', argument " "1"" of type '" "xmlOutputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlOutputBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlNodeDumpOutput', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlNodeDumpOutput', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlNodeDumpOutput" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlNodeDumpOutput" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);if (args[5]->IsNull()) {
    arg6 = NULL;
  } else if (node::Buffer::HasInstance(args[5])) {
    arg6 = node::Buffer::Data(Nan::To<v8::Object>(args[5]).ToLocalChecked());
    // printf("data: %s - %i\n", arg6, strlen(arg6));
  } else {
    res6 = SWIG_AsCharPtrAndSize(args[5], &buf6, &size6, &alloc6);
    
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlNodeDumpOutput" "', argument " "6"" of type '" "char const *""'");
    }
    
    arg6 = reinterpret_cast< char * >(buf6);
  }xmlNodeDumpOutput(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  // free(arg6);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSaveFormatFileEnc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveFormatFileEnc.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSaveFormatFileEnc" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlSaveFormatFileEnc', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSaveFormatFileEnc" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlSaveFormatFileEnc" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (int)xmlSaveFormatFileEnc((char const *)arg1,arg2,(char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  // free(arg1);
  
  // free(arg3);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSaveFileEnc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  char *arg3 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveFileEnc.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSaveFileEnc" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlSaveFileEnc', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSaveFileEnc" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }result = (int)xmlSaveFileEnc((char const *)arg1,arg2,(char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  // free(arg1);
  
  // free(arg3);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlIsXHTML(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlIsXHTML.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlIsXHTML" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlIsXHTML" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlIsXHTML((unsigned char const *)arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetDocCompressMode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDoc *arg1 = (xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetDocCompressMode.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetDocCompressMode', argument 1 of type 'xmlDoc const *'"); 
  }
  arg1 = (xmlDoc *) arg10;result = (int)xmlGetDocCompressMode((_xmlDoc const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSetDocCompressMode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSetDocCompressMode.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlSetDocCompressMode', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlSetDocCompressMode" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlSetDocCompressMode(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetCompressMode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetCompressMode.");
  
  result = (int)xmlGetCompressMode();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSetCompressMode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSetCompressMode.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlSetCompressMode" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);xmlSetCompressMode(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDOMWrapNewCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDOMWrapCtxtPtr result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDOMWrapNewCtxt.");
  
  result = (xmlDOMWrapCtxtPtr)xmlDOMWrapNewCtxt();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlDOMWrapCtxt, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDOMWrapFreeCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDOMWrapCtxtPtr arg1 = (xmlDOMWrapCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDOMWrapFreeCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlDOMWrapCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDOMWrapFreeCtxt" "', argument " "1"" of type '" "xmlDOMWrapCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlDOMWrapCtxtPtr >(argp1);xmlDOMWrapFreeCtxt(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDOMWrapReconcileNamespaces(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDOMWrapCtxtPtr arg1 = (xmlDOMWrapCtxtPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDOMWrapReconcileNamespaces.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlDOMWrapCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDOMWrapReconcileNamespaces" "', argument " "1"" of type '" "xmlDOMWrapCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlDOMWrapCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlDOMWrapReconcileNamespaces', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlDOMWrapReconcileNamespaces" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlDOMWrapReconcileNamespaces(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDOMWrapAdoptNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDOMWrapCtxtPtr arg1 = (xmlDOMWrapCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  xmlDocPtr arg4 = (xmlDocPtr) 0 ;
  xmlNodePtr arg5 = (xmlNodePtr) 0 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int res4 ;
  void *arg40 ;
  int res5 ;
  void *arg50 ;
  int val6 ;
  int ecode6 = 0 ;
  int result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDOMWrapAdoptNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlDOMWrapCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDOMWrapAdoptNode" "', argument " "1"" of type '" "xmlDOMWrapCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlDOMWrapCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlDOMWrapAdoptNode', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlDOMWrapAdoptNode', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);res4 = SWIG_ConvertPtr(args[3], &arg40, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method 'xmlDOMWrapAdoptNode', argument 4 of type 'xmlDocPtr'"); 
  }
  arg4 = (xmlDocPtr) arg40;res5 = SWIG_ConvertPtr(args[4], &arg50, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res5)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[4], &arg50, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[4], &arg50, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[4], &arg50, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[4], &arg50, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method 'xmlDOMWrapAdoptNode', argument 5 of type 'xmlNodePtr'"); 
    }
  }
  
  arg5 = ((xmlNodePtr) arg50);ecode6 = SWIG_AsVal_int(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xmlDOMWrapAdoptNode" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);result = (int)xmlDOMWrapAdoptNode(arg1,arg2,arg3,arg4,arg5,arg6);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDOMWrapRemoveNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDOMWrapCtxtPtr arg1 = (xmlDOMWrapCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDOMWrapRemoveNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlDOMWrapCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDOMWrapRemoveNode" "', argument " "1"" of type '" "xmlDOMWrapCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlDOMWrapCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlDOMWrapRemoveNode', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlDOMWrapRemoveNode', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlDOMWrapRemoveNode" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (int)xmlDOMWrapRemoveNode(arg1,arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDOMWrapCloneNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDOMWrapCtxtPtr arg1 = (xmlDOMWrapCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  xmlNodePtr *arg4 = (xmlNodePtr *) 0 ;
  xmlDocPtr arg5 = (xmlDocPtr) 0 ;
  xmlNodePtr arg6 = (xmlNodePtr) 0 ;
  int arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 ;
  void *arg50 ;
  int res6 ;
  void *arg60 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int result;
  
  if (args.Length() < 8 || args.Length() > 8) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDOMWrapCloneNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlDOMWrapCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDOMWrapCloneNode" "', argument " "1"" of type '" "xmlDOMWrapCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlDOMWrapCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlDOMWrapCloneNode', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlDOMWrapCloneNode', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_p__xmlNode, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlDOMWrapCloneNode" "', argument " "4"" of type '" "xmlNodePtr *""'"); 
  }
  arg4 = reinterpret_cast< xmlNodePtr * >(argp4);res5 = SWIG_ConvertPtr(args[4], &arg50, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method 'xmlDOMWrapCloneNode', argument 5 of type 'xmlDocPtr'"); 
  }
  arg5 = (xmlDocPtr) arg50;res6 = SWIG_ConvertPtr(args[5], &arg60, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res6)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[5], &arg60, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[5], &arg60, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[5], &arg60, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[5], &arg60, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method 'xmlDOMWrapCloneNode', argument 6 of type 'xmlNodePtr'"); 
    }
  }
  
  arg6 = ((xmlNodePtr) arg60);ecode7 = SWIG_AsVal_int(args[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "xmlDOMWrapCloneNode" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);ecode8 = SWIG_AsVal_int(args[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "xmlDOMWrapCloneNode" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);result = (int)xmlDOMWrapCloneNode(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlChildElementCount(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  unsigned long result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlChildElementCount.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlChildElementCount', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);result = (unsigned long)xmlChildElementCount(arg1);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNextElementSibling(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlNodePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNextElementSibling.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNextElementSibling', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);result = (xmlNodePtr)xmlNextElementSibling(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFirstElementChild(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlNodePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFirstElementChild.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlFirstElementChild', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);result = (xmlNodePtr)xmlFirstElementChild(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlLastElementChild(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlNodePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlLastElementChild.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlLastElementChild', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);result = (xmlNodePtr)xmlLastElementChild(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlPreviousElementSibling(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlNodePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlPreviousElementSibling.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlPreviousElementSibling', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);result = (xmlNodePtr)xmlPreviousElementSibling(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRegisterNodeDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRegisterNodeFunc arg1 = (xmlRegisterNodeFunc) 0 ;
  xmlRegisterNodeFunc result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRegisterNodeDefault.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p__xmlNode__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRegisterNodeDefault" "', argument " "1"" of type '" "xmlRegisterNodeFunc""'"); 
      }
    }
  }
  result = (xmlRegisterNodeFunc)xmlRegisterNodeDefault(arg1);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p__xmlNode__void);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDeregisterNodeDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDeregisterNodeFunc arg1 = (xmlDeregisterNodeFunc) 0 ;
  xmlDeregisterNodeFunc result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDeregisterNodeDefault.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p__xmlNode__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlDeregisterNodeDefault" "', argument " "1"" of type '" "xmlDeregisterNodeFunc""'"); 
      }
    }
  }
  result = (xmlDeregisterNodeFunc)xmlDeregisterNodeDefault(arg1);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p__xmlNode__void);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefRegisterNodeDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRegisterNodeFunc arg1 = (xmlRegisterNodeFunc) 0 ;
  xmlRegisterNodeFunc result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefRegisterNodeDefault.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p__xmlNode__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlThrDefRegisterNodeDefault" "', argument " "1"" of type '" "xmlRegisterNodeFunc""'"); 
      }
    }
  }
  result = (xmlRegisterNodeFunc)xmlThrDefRegisterNodeDefault(arg1);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p__xmlNode__void);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefDeregisterNodeDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDeregisterNodeFunc arg1 = (xmlDeregisterNodeFunc) 0 ;
  xmlDeregisterNodeFunc result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefDeregisterNodeDefault.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p__xmlNode__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlThrDefDeregisterNodeDefault" "', argument " "1"" of type '" "xmlDeregisterNodeFunc""'"); 
      }
    }
  }
  result = (xmlDeregisterNodeFunc)xmlThrDefDeregisterNodeDefault(arg1);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p__xmlNode__void);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefBufferAllocScheme(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferAllocationScheme arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  xmlBufferAllocationScheme result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefBufferAllocScheme.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlThrDefBufferAllocScheme" "', argument " "1"" of type '" "xmlBufferAllocationScheme""'");
  } 
  arg1 = static_cast< xmlBufferAllocationScheme >(val1);result = (xmlBufferAllocationScheme)xmlThrDefBufferAllocScheme(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefDefaultBufferSize(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefDefaultBufferSize.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlThrDefDefaultBufferSize" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlThrDefDefaultBufferSize(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlInitializeDict(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlInitializeDict.");
  
  result = (int)xmlInitializeDict();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDictCreate(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDictPtr result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDictCreate.");
  
  result = (xmlDictPtr)xmlDictCreate();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlDict, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDictSetLimit(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDictPtr arg1 = (xmlDictPtr) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDictSetLimit.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDictSetLimit" "', argument " "1"" of type '" "xmlDictPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlDictPtr >(argp1);ecode2 = SWIG_AsVal_size_t(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlDictSetLimit" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);result = xmlDictSetLimit(arg1,SWIG_STD_MOVE(arg2));
  jsresult = SWIG_From_size_t(static_cast< size_t >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDictGetUsage(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDictPtr arg1 = (xmlDictPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDictGetUsage.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDictGetUsage" "', argument " "1"" of type '" "xmlDictPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlDictPtr >(argp1);result = xmlDictGetUsage(arg1);
  jsresult = SWIG_From_size_t(static_cast< size_t >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDictCreateSub(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDictPtr arg1 = (xmlDictPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlDictPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDictCreateSub.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDictCreateSub" "', argument " "1"" of type '" "xmlDictPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlDictPtr >(argp1);result = (xmlDictPtr)xmlDictCreateSub(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlDict, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDictReference(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDictPtr arg1 = (xmlDictPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDictReference.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDictReference" "', argument " "1"" of type '" "xmlDictPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlDictPtr >(argp1);result = (int)xmlDictReference(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDictFree(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDictPtr arg1 = (xmlDictPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDictFree.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDictFree" "', argument " "1"" of type '" "xmlDictPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlDictPtr >(argp1);xmlDictFree(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDictLookup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDictPtr arg1 = (xmlDictPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDictLookup.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDictLookup" "', argument " "1"" of type '" "xmlDictPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlDictPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlDictLookup" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlDictLookup" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlChar *)xmlDictLookup(arg1,(unsigned char const *)arg2,arg3);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDictExists(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDictPtr arg1 = (xmlDictPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDictExists.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDictExists" "', argument " "1"" of type '" "xmlDictPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlDictPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlDictExists" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlDictExists" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlChar *)xmlDictExists(arg1,(unsigned char const *)arg2,arg3);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDictQLookup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDictPtr arg1 = (xmlDictPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDictQLookup.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDictQLookup" "', argument " "1"" of type '" "xmlDictPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlDictPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlDictQLookup" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlDictQLookup" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlChar *)xmlDictQLookup(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDictOwns(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDictPtr arg1 = (xmlDictPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDictOwns.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDictOwns" "', argument " "1"" of type '" "xmlDictPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlDictPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlDictOwns" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlDictOwns(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDictSize(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDictPtr arg1 = (xmlDictPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDictSize.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlDict, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDictSize" "', argument " "1"" of type '" "xmlDictPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlDictPtr >(argp1);result = (int)xmlDictSize(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDictCleanup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDictCleanup.");
  
  xmlDictCleanup();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashCreate(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  xmlHashTablePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashCreate.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlHashCreate" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (xmlHashTablePtr)xmlHashCreate(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashCreateDict(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  xmlDictPtr arg2 = (xmlDictPtr) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlHashTablePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashCreateDict.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlHashCreateDict" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlDict, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashCreateDict" "', argument " "2"" of type '" "xmlDictPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlDictPtr >(argp2);result = (xmlHashTablePtr)xmlHashCreateDict(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashFree(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlHashDeallocator arg2 = (xmlHashDeallocator) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashFree.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashFree" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlHashFree" "', argument " "2"" of type '" "xmlHashDeallocator""'"); 
      }
    }
  }
  xmlHashFree(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashDefaultDeallocator(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashDefaultDeallocator.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashDefaultDeallocator" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }xmlHashDefaultDeallocator(arg1,(unsigned char const *)arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashAdd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashAdd.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashAdd" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashAdd" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }arg3 = getSwigCObjectPtr(args[2]);result = (int)xmlHashAdd(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashAddEntry(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashAddEntry.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashAddEntry" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashAddEntry" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }arg3 = getSwigCObjectPtr(args[2]);result = (int)xmlHashAddEntry(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashUpdateEntry(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *arg3 = (void *) 0 ;
  xmlHashDeallocator arg4 = (xmlHashDeallocator) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashUpdateEntry.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashUpdateEntry" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashUpdateEntry" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }arg3 = getSwigCObjectPtr(args[2]);{
    {
      int res = SWIG_ConvertFunctionPtr(args[3], (void**)(&arg4), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlHashUpdateEntry" "', argument " "4"" of type '" "xmlHashDeallocator""'"); 
      }
    }
  }
  result = (int)xmlHashUpdateEntry(arg1,(unsigned char const *)arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashAdd2(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashAdd2.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashAdd2" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashAdd2" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlHashAdd2" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }arg4 = getSwigCObjectPtr(args[3]);result = (int)xmlHashAdd2(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashAddEntry2(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashAddEntry2.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashAddEntry2" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashAddEntry2" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlHashAddEntry2" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }arg4 = getSwigCObjectPtr(args[3]);result = (int)xmlHashAddEntry2(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashUpdateEntry2(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *arg4 = (void *) 0 ;
  xmlHashDeallocator arg5 = (xmlHashDeallocator) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashUpdateEntry2.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashUpdateEntry2" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashUpdateEntry2" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlHashUpdateEntry2" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }arg4 = getSwigCObjectPtr(args[3]);{
    {
      int res = SWIG_ConvertFunctionPtr(args[4], (void**)(&arg5), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlHashUpdateEntry2" "', argument " "5"" of type '" "xmlHashDeallocator""'"); 
      }
    }
  }
  result = (int)xmlHashUpdateEntry2(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashAdd3(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  void *arg5 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashAdd3.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashAdd3" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashAdd3" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlHashAdd3" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlHashAdd3" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }arg5 = getSwigCObjectPtr(args[4]);result = (int)xmlHashAdd3(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashAddEntry3(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  void *arg5 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashAddEntry3.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashAddEntry3" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashAddEntry3" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlHashAddEntry3" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlHashAddEntry3" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }arg5 = getSwigCObjectPtr(args[4]);result = (int)xmlHashAddEntry3(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashUpdateEntry3(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  void *arg5 = (void *) 0 ;
  xmlHashDeallocator arg6 = (xmlHashDeallocator) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashUpdateEntry3.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashUpdateEntry3" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashUpdateEntry3" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlHashUpdateEntry3" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlHashUpdateEntry3" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }arg5 = getSwigCObjectPtr(args[4]);{
    {
      int res = SWIG_ConvertFunctionPtr(args[5], (void**)(&arg6), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlHashUpdateEntry3" "', argument " "6"" of type '" "xmlHashDeallocator""'"); 
      }
    }
  }
  result = (int)xmlHashUpdateEntry3(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,arg5,arg6);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashRemoveEntry(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlHashDeallocator arg3 = (xmlHashDeallocator) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashRemoveEntry.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashRemoveEntry" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashRemoveEntry" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }{
    {
      int res = SWIG_ConvertFunctionPtr(args[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlHashRemoveEntry" "', argument " "3"" of type '" "xmlHashDeallocator""'"); 
      }
    }
  }
  result = (int)xmlHashRemoveEntry(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashRemoveEntry2(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlHashDeallocator arg4 = (xmlHashDeallocator) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashRemoveEntry2.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashRemoveEntry2" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashRemoveEntry2" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlHashRemoveEntry2" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }{
    {
      int res = SWIG_ConvertFunctionPtr(args[3], (void**)(&arg4), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlHashRemoveEntry2" "', argument " "4"" of type '" "xmlHashDeallocator""'"); 
      }
    }
  }
  result = (int)xmlHashRemoveEntry2(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashRemoveEntry3(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlHashDeallocator arg5 = (xmlHashDeallocator) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashRemoveEntry3.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashRemoveEntry3" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashRemoveEntry3" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlHashRemoveEntry3" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlHashRemoveEntry3" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }{
    {
      int res = SWIG_ConvertFunctionPtr(args[4], (void**)(&arg5), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlHashRemoveEntry3" "', argument " "5"" of type '" "xmlHashDeallocator""'"); 
      }
    }
  }
  result = (int)xmlHashRemoveEntry3(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashLookup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashLookup.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashLookup" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashLookup" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (void *)xmlHashLookup(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashLookup2(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  void *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashLookup2.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashLookup2" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashLookup2" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlHashLookup2" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (void *)xmlHashLookup2(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashLookup3(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  void *result = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashLookup3.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashLookup3" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashLookup3" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlHashLookup3" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlHashLookup3" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (void *)xmlHashLookup3(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashQLookup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  void *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashQLookup.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashQLookup" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashQLookup" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlHashQLookup" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (void *)xmlHashQLookup(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashQLookup2(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  void *result = 0 ;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashQLookup2.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashQLookup2" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashQLookup2" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlHashQLookup2" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlHashQLookup2" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlHashQLookup2" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }result = (void *)xmlHashQLookup2(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,(unsigned char const *)arg5);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashQLookup3(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  xmlChar *arg6 = (xmlChar *) 0 ;
  xmlChar *arg7 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  size_t size6 = 0 ;
  int alloc6 = 0 ;
  int res7 ;
  char *buf7 = 0 ;
  size_t size7 = 0 ;
  int alloc7 = 0 ;
  void *result = 0 ;
  
  if (args.Length() < 7 || args.Length() > 7) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashQLookup3.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashQLookup3" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashQLookup3" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlHashQLookup3" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlHashQLookup3" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlHashQLookup3" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }if (args[5]->IsNull()) {
    arg6 = NULL;
  } else {
    res6 = SWIG_AsCharPtrAndSize(args[5], &buf6, &size6, &alloc6);
    
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlHashQLookup3" "', argument " "6"" of type '" "xmlChar const *""'");
    }
    
    arg6 = reinterpret_cast< xmlChar * >(buf6);
  }if (args[6]->IsNull()) {
    arg7 = NULL;
  } else {
    res7 = SWIG_AsCharPtrAndSize(args[6], &buf7, &size7, &alloc7);
    
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "xmlHashQLookup3" "', argument " "7"" of type '" "xmlChar const *""'");
    }
    
    arg7 = reinterpret_cast< xmlChar * >(buf7);
  }result = (void *)xmlHashQLookup3(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,(unsigned char const *)arg5,(unsigned char const *)arg6,(unsigned char const *)arg7);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashCopySafe(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlHashCopier arg2 = (xmlHashCopier) 0 ;
  xmlHashDeallocator arg3 = (xmlHashDeallocator) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlHashTablePtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashCopySafe.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashCopySafe" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__p_void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlHashCopySafe" "', argument " "2"" of type '" "xmlHashCopier""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlHashCopySafe" "', argument " "3"" of type '" "xmlHashDeallocator""'"); 
      }
    }
  }
  result = (xmlHashTablePtr)xmlHashCopySafe(arg1,arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashCopy(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlHashCopier arg2 = (xmlHashCopier) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlHashTablePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashCopy.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashCopy" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__p_void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlHashCopy" "', argument " "2"" of type '" "xmlHashCopier""'"); 
      }
    }
  }
  result = (xmlHashTablePtr)xmlHashCopy(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashSize(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashSize.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashSize" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);result = (int)xmlHashSize(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashScan(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlHashScanner arg2 = (xmlHashScanner) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashScan.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashScan" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_void_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlHashScan" "', argument " "2"" of type '" "xmlHashScanner""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);xmlHashScan(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashScan3(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlHashScanner arg5 = (xmlHashScanner) 0 ;
  void *arg6 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashScan3.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashScan3" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashScan3" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlHashScan3" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlHashScan3" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }{
    {
      int res = SWIG_ConvertFunctionPtr(args[4], (void**)(&arg5), SWIGTYPE_p_f_p_void_p_void_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlHashScan3" "', argument " "5"" of type '" "xmlHashScanner""'"); 
      }
    }
  }
  arg6 = getSwigCObjectPtr(args[5]);xmlHashScan3(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,arg5,arg6);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashScanFull(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlHashScannerFull arg2 = (xmlHashScannerFull) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashScanFull.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashScanFull" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlHashScanFull" "', argument " "2"" of type '" "xmlHashScannerFull""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);xmlHashScanFull(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlHashScanFull3(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlHashTablePtr arg1 = (xmlHashTablePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlHashScannerFull arg5 = (xmlHashScannerFull) 0 ;
  void *arg6 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHashScanFull3.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHashScanFull3" "', argument " "1"" of type '" "xmlHashTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlHashTablePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlHashScanFull3" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlHashScanFull3" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlHashScanFull3" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }{
    {
      int res = SWIG_ConvertFunctionPtr(args[4], (void**)(&arg5), SWIGTYPE_p_f_p_void_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlHashScanFull3" "', argument " "5"" of type '" "xmlHashScannerFull""'"); 
      }
    }
  }
  arg6 = getSwigCObjectPtr(args[5]);xmlHashScanFull3(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,arg5,arg6);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_ERR_NONE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_NONE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_WARNING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_WARNING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_FATAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_FATAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_NONE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_NONE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_PARSER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_PARSER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_TREE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_TREE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_NAMESPACE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_NAMESPACE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_DTD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_DTD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_HTML_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_HTML));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_MEMORY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_MEMORY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_OUTPUT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_OUTPUT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_IO_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_IO));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_FTP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_FTP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_HTTP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_HTTP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_XINCLUDE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_XINCLUDE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_XPATH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_XPATH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_XPOINTER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_XPOINTER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_REGEXP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_REGEXP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_DATATYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_DATATYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_SCHEMASP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_SCHEMASP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_SCHEMASV_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_SCHEMASV));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_RELAXNGP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_RELAXNGP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_RELAXNGV_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_RELAXNGV));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_CATALOG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_CATALOG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_C14N_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_C14N));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_XSLT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_XSLT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_VALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_VALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_CHECK_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_CHECK));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_WRITER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_WRITER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_MODULE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_MODULE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_I18N_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_I18N));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_SCHEMATRONV_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_SCHEMATRONV));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_BUFFER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_BUFFER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FROM_URI_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FROM_URI));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlError_domain_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlError *arg1 = (_xmlError *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_domain_set" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlError_domain_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->domain = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlError_domain_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlError *arg1 = (_xmlError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_domain_get" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);result = (int) ((arg1)->domain);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlError_code_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlError *arg1 = (_xmlError *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_code_set" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlError_code_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->code = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlError_code_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlError *arg1 = (_xmlError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_code_get" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);result = (int) ((arg1)->code);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlError_message_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlError *arg1 = (_xmlError *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_message_set" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlError_message_set" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }delete[] arg1->message;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->message = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->message = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlError_message_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlError *arg1 = (_xmlError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_message_get" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);result = (char *) ((arg1)->message);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlError_level_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlError *arg1 = (_xmlError *) 0 ;
  xmlErrorLevel arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_level_set" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlError_level_set" "', argument " "2"" of type '" "xmlErrorLevel""'");
  } 
  arg2 = static_cast< xmlErrorLevel >(val2);if (arg1) (arg1)->level = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlError_level_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlError *arg1 = (_xmlError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlErrorLevel result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_level_get" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);result = (xmlErrorLevel) ((arg1)->level);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlError_file_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlError *arg1 = (_xmlError *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_file_set" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlError_file_set" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }delete[] arg1->file;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->file = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->file = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlError_file_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlError *arg1 = (_xmlError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_file_get" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);result = (char *) ((arg1)->file);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlError_line_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlError *arg1 = (_xmlError *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_line_set" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlError_line_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->line = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlError_line_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlError *arg1 = (_xmlError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_line_get" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);result = (int) ((arg1)->line);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlError_str1_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlError *arg1 = (_xmlError *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_str1_set" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlError_str1_set" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }delete[] arg1->str1;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->str1 = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->str1 = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlError_str1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlError *arg1 = (_xmlError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_str1_get" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);result = (char *) ((arg1)->str1);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlError_str2_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlError *arg1 = (_xmlError *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_str2_set" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlError_str2_set" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }delete[] arg1->str2;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->str2 = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->str2 = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlError_str2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlError *arg1 = (_xmlError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_str2_get" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);result = (char *) ((arg1)->str2);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlError_str3_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlError *arg1 = (_xmlError *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_str3_set" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlError_str3_set" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }delete[] arg1->str3;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->str3 = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->str3 = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlError_str3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlError *arg1 = (_xmlError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_str3_get" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);result = (char *) ((arg1)->str3);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlError_int1_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlError *arg1 = (_xmlError *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_int1_set" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlError_int1_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->int1 = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlError_int1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlError *arg1 = (_xmlError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_int1_get" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);result = (int) ((arg1)->int1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlError_int2_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlError *arg1 = (_xmlError *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_int2_set" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlError_int2_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->int2 = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlError_int2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlError *arg1 = (_xmlError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_int2_get" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);result = (int) ((arg1)->int2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlError_ctxt_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlError *arg1 = (_xmlError *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_ctxt_set" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->ctxt = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlError_ctxt_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlError *arg1 = (_xmlError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_ctxt_get" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);result = (void *) ((arg1)->ctxt);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlError_node_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlError *arg1 = (_xmlError *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_node_set" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->node = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlError_node_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlError *arg1 = (_xmlError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlError_node_get" "', argument " "1"" of type '" "_xmlError *""'"); 
  }
  arg1 = reinterpret_cast< _xmlError * >(argp1);result = (void *) ((arg1)->node);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlError *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlError.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlError.");
  result = (_xmlError *)new _xmlError();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlError, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlError(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlError * arg1 = (_xmlError *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue exports_XML_ERR_OK_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_OK));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_INTERNAL_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_INTERNAL_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_NO_MEMORY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_NO_MEMORY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_DOCUMENT_START_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_DOCUMENT_START));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_DOCUMENT_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_DOCUMENT_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_DOCUMENT_END_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_DOCUMENT_END));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_INVALID_HEX_CHARREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_INVALID_HEX_CHARREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_INVALID_DEC_CHARREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_INVALID_DEC_CHARREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_INVALID_CHARREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_INVALID_CHARREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_INVALID_CHAR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_INVALID_CHAR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_CHARREF_AT_EOF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_CHARREF_AT_EOF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_CHARREF_IN_PROLOG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_CHARREF_IN_PROLOG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_CHARREF_IN_EPILOG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_CHARREF_IN_EPILOG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_CHARREF_IN_DTD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_CHARREF_IN_DTD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ENTITYREF_AT_EOF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ENTITYREF_AT_EOF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ENTITYREF_IN_PROLOG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ENTITYREF_IN_PROLOG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ENTITYREF_IN_EPILOG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ENTITYREF_IN_EPILOG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ENTITYREF_IN_DTD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ENTITYREF_IN_DTD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_PEREF_AT_EOF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_PEREF_AT_EOF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_PEREF_IN_PROLOG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_PEREF_IN_PROLOG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_PEREF_IN_EPILOG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_PEREF_IN_EPILOG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_PEREF_IN_INT_SUBSET_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_PEREF_IN_INT_SUBSET));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ENTITYREF_NO_NAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ENTITYREF_NO_NAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ENTITYREF_SEMICOL_MISSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ENTITYREF_SEMICOL_MISSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_PEREF_NO_NAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_PEREF_NO_NAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_PEREF_SEMICOL_MISSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_PEREF_SEMICOL_MISSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_UNDECLARED_ENTITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_UNDECLARED_ENTITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WAR_UNDECLARED_ENTITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WAR_UNDECLARED_ENTITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_UNPARSED_ENTITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_UNPARSED_ENTITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ENTITY_IS_EXTERNAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ENTITY_IS_EXTERNAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ENTITY_IS_PARAMETER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ENTITY_IS_PARAMETER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_UNKNOWN_ENCODING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_UNKNOWN_ENCODING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_UNSUPPORTED_ENCODING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_UNSUPPORTED_ENCODING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_STRING_NOT_STARTED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_STRING_NOT_STARTED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_STRING_NOT_CLOSED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_STRING_NOT_CLOSED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_NS_DECL_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_NS_DECL_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ENTITY_NOT_STARTED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ENTITY_NOT_STARTED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ENTITY_NOT_FINISHED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ENTITY_NOT_FINISHED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_LT_IN_ATTRIBUTE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_LT_IN_ATTRIBUTE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ATTRIBUTE_NOT_STARTED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ATTRIBUTE_NOT_STARTED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ATTRIBUTE_NOT_FINISHED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ATTRIBUTE_NOT_FINISHED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ATTRIBUTE_WITHOUT_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ATTRIBUTE_WITHOUT_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ATTRIBUTE_REDEFINED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ATTRIBUTE_REDEFINED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_LITERAL_NOT_STARTED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_LITERAL_NOT_STARTED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_LITERAL_NOT_FINISHED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_LITERAL_NOT_FINISHED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_COMMENT_NOT_FINISHED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_COMMENT_NOT_FINISHED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_PI_NOT_STARTED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_PI_NOT_STARTED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_PI_NOT_FINISHED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_PI_NOT_FINISHED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_NOTATION_NOT_STARTED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_NOTATION_NOT_STARTED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_NOTATION_NOT_FINISHED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_NOTATION_NOT_FINISHED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ATTLIST_NOT_STARTED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ATTLIST_NOT_STARTED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ATTLIST_NOT_FINISHED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ATTLIST_NOT_FINISHED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_MIXED_NOT_STARTED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_MIXED_NOT_STARTED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_MIXED_NOT_FINISHED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_MIXED_NOT_FINISHED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ELEMCONTENT_NOT_STARTED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ELEMCONTENT_NOT_STARTED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ELEMCONTENT_NOT_FINISHED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ELEMCONTENT_NOT_FINISHED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_XMLDECL_NOT_STARTED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_XMLDECL_NOT_STARTED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_XMLDECL_NOT_FINISHED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_XMLDECL_NOT_FINISHED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_CONDSEC_NOT_STARTED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_CONDSEC_NOT_STARTED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_CONDSEC_NOT_FINISHED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_CONDSEC_NOT_FINISHED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_EXT_SUBSET_NOT_FINISHED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_EXT_SUBSET_NOT_FINISHED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_DOCTYPE_NOT_FINISHED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_DOCTYPE_NOT_FINISHED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_MISPLACED_CDATA_END_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_MISPLACED_CDATA_END));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_CDATA_NOT_FINISHED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_CDATA_NOT_FINISHED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_RESERVED_XML_NAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_RESERVED_XML_NAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_SPACE_REQUIRED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_SPACE_REQUIRED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_SEPARATOR_REQUIRED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_SEPARATOR_REQUIRED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_NMTOKEN_REQUIRED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_NMTOKEN_REQUIRED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_NAME_REQUIRED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_NAME_REQUIRED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_PCDATA_REQUIRED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_PCDATA_REQUIRED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_URI_REQUIRED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_URI_REQUIRED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_PUBID_REQUIRED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_PUBID_REQUIRED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_LT_REQUIRED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_LT_REQUIRED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_GT_REQUIRED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_GT_REQUIRED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_LTSLASH_REQUIRED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_LTSLASH_REQUIRED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_EQUAL_REQUIRED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_EQUAL_REQUIRED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_TAG_NAME_MISMATCH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_TAG_NAME_MISMATCH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_TAG_NOT_FINISHED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_TAG_NOT_FINISHED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_STANDALONE_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_STANDALONE_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ENCODING_NAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ENCODING_NAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_HYPHEN_IN_COMMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_HYPHEN_IN_COMMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_INVALID_ENCODING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_INVALID_ENCODING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_EXT_ENTITY_STANDALONE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_EXT_ENTITY_STANDALONE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_CONDSEC_INVALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_CONDSEC_INVALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_VALUE_REQUIRED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_VALUE_REQUIRED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_NOT_WELL_BALANCED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_NOT_WELL_BALANCED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_EXTRA_CONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_EXTRA_CONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ENTITY_CHAR_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ENTITY_CHAR_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ENTITY_PE_INTERNAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ENTITY_PE_INTERNAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ENTITY_LOOP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ENTITY_LOOP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ENTITY_BOUNDARY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ENTITY_BOUNDARY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_INVALID_URI_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_INVALID_URI));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_URI_FRAGMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_URI_FRAGMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WAR_CATALOG_PI_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WAR_CATALOG_PI));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_NO_DTD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_NO_DTD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_CONDSEC_INVALID_KEYWORD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_CONDSEC_INVALID_KEYWORD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_VERSION_MISSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_VERSION_MISSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WAR_UNKNOWN_VERSION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WAR_UNKNOWN_VERSION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WAR_LANG_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WAR_LANG_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WAR_NS_URI_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WAR_NS_URI));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WAR_NS_URI_RELATIVE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WAR_NS_URI_RELATIVE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_MISSING_ENCODING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_MISSING_ENCODING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WAR_SPACE_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WAR_SPACE_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_NOT_STANDALONE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_NOT_STANDALONE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ENTITY_PROCESSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ENTITY_PROCESSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_NOTATION_PROCESSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_NOTATION_PROCESSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WAR_NS_COLUMN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WAR_NS_COLUMN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WAR_ENTITY_REDEFINED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WAR_ENTITY_REDEFINED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_UNKNOWN_VERSION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_UNKNOWN_VERSION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_VERSION_MISMATCH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_VERSION_MISMATCH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_NAME_TOO_LONG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_NAME_TOO_LONG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_USER_STOP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_USER_STOP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_COMMENT_ABRUPTLY_ENDED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_COMMENT_ABRUPTLY_ENDED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WAR_ENCODING_MISMATCH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WAR_ENCODING_MISMATCH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_RESOURCE_LIMIT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_RESOURCE_LIMIT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_ARGUMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_ARGUMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_SYSTEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_SYSTEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_REDECL_PREDEF_ENTITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_REDECL_PREDEF_ENTITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ERR_INT_SUBSET_NOT_FINISHED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ERR_INT_SUBSET_NOT_FINISHED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_NS_ERR_XML_NAMESPACE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_NS_ERR_XML_NAMESPACE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_NS_ERR_UNDEFINED_NAMESPACE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_NS_ERR_UNDEFINED_NAMESPACE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_NS_ERR_QNAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_NS_ERR_QNAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_NS_ERR_ATTRIBUTE_REDEFINED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_NS_ERR_ATTRIBUTE_REDEFINED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_NS_ERR_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_NS_ERR_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_NS_ERR_COLON_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_NS_ERR_COLON));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_ATTRIBUTE_DEFAULT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_ATTRIBUTE_DEFAULT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_ATTRIBUTE_REDEFINED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_ATTRIBUTE_REDEFINED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_ATTRIBUTE_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_ATTRIBUTE_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_CONTENT_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_CONTENT_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_CONTENT_MODEL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_CONTENT_MODEL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_CONTENT_NOT_DETERMINIST_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_CONTENT_NOT_DETERMINIST));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_DIFFERENT_PREFIX_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_DIFFERENT_PREFIX));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_ELEM_DEFAULT_NAMESPACE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_ELEM_DEFAULT_NAMESPACE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_ELEM_NAMESPACE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_ELEM_NAMESPACE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_ELEM_REDEFINED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_ELEM_REDEFINED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_EMPTY_NOTATION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_EMPTY_NOTATION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_ENTITY_TYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_ENTITY_TYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_ID_FIXED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_ID_FIXED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_ID_REDEFINED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_ID_REDEFINED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_ID_SUBSET_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_ID_SUBSET));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_INVALID_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_INVALID_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_INVALID_DEFAULT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_INVALID_DEFAULT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_LOAD_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_LOAD_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_MISSING_ATTRIBUTE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_MISSING_ATTRIBUTE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_MIXED_CORRUPT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_MIXED_CORRUPT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_MULTIPLE_ID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_MULTIPLE_ID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_NO_DOC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_NO_DOC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_NO_DTD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_NO_DTD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_NO_ELEM_NAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_NO_ELEM_NAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_NO_PREFIX_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_NO_PREFIX));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_NO_ROOT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_NO_ROOT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_NOTATION_REDEFINED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_NOTATION_REDEFINED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_NOTATION_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_NOTATION_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_NOT_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_NOT_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_NOT_PCDATA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_NOT_PCDATA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_NOT_STANDALONE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_NOT_STANDALONE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_ROOT_NAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_ROOT_NAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_STANDALONE_WHITE_SPACE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_STANDALONE_WHITE_SPACE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_UNKNOWN_ATTRIBUTE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_UNKNOWN_ATTRIBUTE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_UNKNOWN_ELEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_UNKNOWN_ELEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_UNKNOWN_ENTITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_UNKNOWN_ENTITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_UNKNOWN_ID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_UNKNOWN_ID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_UNKNOWN_NOTATION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_UNKNOWN_NOTATION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_STANDALONE_DEFAULTED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_STANDALONE_DEFAULTED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_XMLID_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_XMLID_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_XMLID_TYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_XMLID_TYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DTD_DUP_TOKEN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DTD_DUP_TOKEN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_HTML_STRUCURE_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_HTML_STRUCURE_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_HTML_UNKNOWN_TAG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_HTML_UNKNOWN_TAG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_HTML_INCORRECTLY_OPENED_COMMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_HTML_INCORRECTLY_OPENED_COMMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_ANYNAME_ATTR_ANCESTOR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_ANYNAME_ATTR_ANCESTOR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_ATTR_CONFLICT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_ATTR_CONFLICT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_ATTRIBUTE_CHILDREN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_ATTRIBUTE_CHILDREN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_ATTRIBUTE_CONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_ATTRIBUTE_CONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_ATTRIBUTE_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_ATTRIBUTE_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_ATTRIBUTE_NOOP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_ATTRIBUTE_NOOP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_CHOICE_CONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_CHOICE_CONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_CHOICE_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_CHOICE_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_CREATE_FAILURE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_CREATE_FAILURE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_DATA_CONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_DATA_CONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_DEF_CHOICE_AND_INTERLEAVE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_DEF_CHOICE_AND_INTERLEAVE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_DEFINE_CREATE_FAILED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_DEFINE_CREATE_FAILED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_DEFINE_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_DEFINE_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_DEFINE_MISSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_DEFINE_MISSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_DEFINE_NAME_MISSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_DEFINE_NAME_MISSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_ELEM_CONTENT_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_ELEM_CONTENT_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_ELEM_CONTENT_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_ELEM_CONTENT_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_ELEMENT_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_ELEMENT_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_ELEMENT_CONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_ELEMENT_CONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_ELEMENT_NAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_ELEMENT_NAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_ELEMENT_NO_CONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_ELEMENT_NO_CONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_ELEM_TEXT_CONFLICT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_ELEM_TEXT_CONFLICT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_EMPTY_CONSTRUCT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_EMPTY_CONSTRUCT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_EMPTY_CONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_EMPTY_CONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_EMPTY_NOT_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_EMPTY_NOT_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_ERROR_TYPE_LIB_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_ERROR_TYPE_LIB));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_EXCEPT_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_EXCEPT_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_EXCEPT_MISSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_EXCEPT_MISSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_EXCEPT_MULTIPLE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_EXCEPT_MULTIPLE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_EXCEPT_NO_CONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_EXCEPT_NO_CONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_EXTERNALREF_EMTPY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_EXTERNALREF_EMTPY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_EXTERNAL_REF_FAILURE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_EXTERNAL_REF_FAILURE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_EXTERNALREF_RECURSE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_EXTERNALREF_RECURSE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_FORBIDDEN_ATTRIBUTE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_FORBIDDEN_ATTRIBUTE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_FOREIGN_ELEMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_FOREIGN_ELEMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_GRAMMAR_CONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_GRAMMAR_CONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_GRAMMAR_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_GRAMMAR_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_GRAMMAR_MISSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_GRAMMAR_MISSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_GRAMMAR_NO_START_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_GRAMMAR_NO_START));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_GROUP_ATTR_CONFLICT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_GROUP_ATTR_CONFLICT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_HREF_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_HREF_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_INCLUDE_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_INCLUDE_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_INCLUDE_FAILURE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_INCLUDE_FAILURE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_INCLUDE_RECURSE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_INCLUDE_RECURSE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_INTERLEAVE_ADD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_INTERLEAVE_ADD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_INTERLEAVE_CREATE_FAILED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_INTERLEAVE_CREATE_FAILED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_INTERLEAVE_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_INTERLEAVE_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_INTERLEAVE_NO_CONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_INTERLEAVE_NO_CONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_INVALID_DEFINE_NAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_INVALID_DEFINE_NAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_INVALID_URI_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_INVALID_URI));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_INVALID_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_INVALID_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_MISSING_HREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_MISSING_HREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_NAME_MISSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_NAME_MISSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_NEED_COMBINE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_NEED_COMBINE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_NOTALLOWED_NOT_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_NOTALLOWED_NOT_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_NSNAME_ATTR_ANCESTOR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_NSNAME_ATTR_ANCESTOR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_NSNAME_NO_NS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_NSNAME_NO_NS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PARAM_FORBIDDEN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PARAM_FORBIDDEN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PARAM_NAME_MISSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PARAM_NAME_MISSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PARENTREF_CREATE_FAILED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PARENTREF_CREATE_FAILED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PARENTREF_NAME_INVALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PARENTREF_NAME_INVALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PARENTREF_NO_NAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PARENTREF_NO_NAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PARENTREF_NO_PARENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PARENTREF_NO_PARENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PARENTREF_NOT_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PARENTREF_NOT_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PARSE_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PARSE_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_ATTR_ATTR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_ATTR_ATTR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_ATTR_ELEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_ATTR_ELEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_DATA_EXCEPT_ATTR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_DATA_EXCEPT_ATTR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_DATA_EXCEPT_ELEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_DATA_EXCEPT_ELEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_DATA_EXCEPT_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_DATA_EXCEPT_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_DATA_EXCEPT_GROUP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_DATA_EXCEPT_GROUP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_DATA_EXCEPT_LIST_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_DATA_EXCEPT_LIST));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_DATA_EXCEPT_ONEMORE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_DATA_EXCEPT_ONEMORE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_DATA_EXCEPT_REF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_DATA_EXCEPT_REF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_DATA_EXCEPT_TEXT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_DATA_EXCEPT_TEXT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_LIST_ATTR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_LIST_ATTR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_LIST_ELEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_LIST_ELEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_LIST_INTERLEAVE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_LIST_INTERLEAVE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_LIST_LIST_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_LIST_LIST));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_LIST_REF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_LIST_REF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_LIST_TEXT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_LIST_TEXT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_ONEMORE_GROUP_ATTR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_ONEMORE_GROUP_ATTR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_START_ATTR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_START_ATTR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_START_DATA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_START_DATA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_START_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_START_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_START_GROUP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_START_GROUP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_START_INTERLEAVE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_START_INTERLEAVE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_START_LIST_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_START_LIST));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_START_ONEMORE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_START_ONEMORE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_START_TEXT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_START_TEXT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PAT_START_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PAT_START_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_PREFIX_UNDEFINED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_PREFIX_UNDEFINED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_REF_CREATE_FAILED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_REF_CREATE_FAILED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_REF_CYCLE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_REF_CYCLE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_REF_NAME_INVALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_REF_NAME_INVALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_REF_NO_DEF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_REF_NO_DEF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_REF_NO_NAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_REF_NO_NAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_REF_NOT_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_REF_NOT_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_START_CHOICE_AND_INTERLEAVE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_START_CHOICE_AND_INTERLEAVE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_START_CONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_START_CONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_START_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_START_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_START_MISSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_START_MISSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_TEXT_EXPECTED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_TEXT_EXPECTED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_TEXT_HAS_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_TEXT_HAS_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_TYPE_MISSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_TYPE_MISSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_TYPE_NOT_FOUND_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_TYPE_NOT_FOUND));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_TYPE_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_TYPE_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_UNKNOWN_ATTRIBUTE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_UNKNOWN_ATTRIBUTE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_UNKNOWN_COMBINE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_UNKNOWN_COMBINE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_UNKNOWN_CONSTRUCT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_UNKNOWN_CONSTRUCT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_UNKNOWN_TYPE_LIB_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_UNKNOWN_TYPE_LIB));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_URI_FRAGMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_URI_FRAGMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_URI_NOT_ABSOLUTE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_URI_NOT_ABSOLUTE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_VALUE_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_VALUE_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_VALUE_NO_CONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_VALUE_NO_CONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_XMLNS_NAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_XMLNS_NAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RNGP_XML_NS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RNGP_XML_NS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_EXPRESSION_OK_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_EXPRESSION_OK));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_NUMBER_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_NUMBER_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_UNFINISHED_LITERAL_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_UNFINISHED_LITERAL_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_START_LITERAL_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_START_LITERAL_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_VARIABLE_REF_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_VARIABLE_REF_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_UNDEF_VARIABLE_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_UNDEF_VARIABLE_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_INVALID_PREDICATE_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_INVALID_PREDICATE_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_EXPR_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_EXPR_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_UNCLOSED_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_UNCLOSED_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_UNKNOWN_FUNC_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_UNKNOWN_FUNC_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_INVALID_OPERAND_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_INVALID_OPERAND));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_INVALID_TYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_INVALID_TYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_INVALID_ARITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_INVALID_ARITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_INVALID_CTXT_SIZE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_INVALID_CTXT_SIZE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_INVALID_CTXT_POSITION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_INVALID_CTXT_POSITION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_MEMORY_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_MEMORY_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPTR_SYNTAX_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPTR_SYNTAX_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPTR_RESOURCE_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPTR_RESOURCE_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPTR_SUB_RESOURCE_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPTR_SUB_RESOURCE_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_UNDEF_PREFIX_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_UNDEF_PREFIX_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_ENCODING_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_ENCODING_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_INVALID_CHAR_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPATH_INVALID_CHAR_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_TREE_INVALID_HEX_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_TREE_INVALID_HEX));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_TREE_INVALID_DEC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_TREE_INVALID_DEC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_TREE_UNTERMINATED_ENTITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_TREE_UNTERMINATED_ENTITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_TREE_NOT_UTF8_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_TREE_NOT_UTF8));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SAVE_NOT_UTF8_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SAVE_NOT_UTF8));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SAVE_CHAR_INVALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SAVE_CHAR_INVALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SAVE_NO_DOCTYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SAVE_NO_DOCTYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SAVE_UNKNOWN_ENCODING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SAVE_UNKNOWN_ENCODING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_REGEXP_COMPILE_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_REGEXP_COMPILE_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_UNKNOWN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_UNKNOWN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EACCES_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EACCES));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EAGAIN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EAGAIN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EBADF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EBADF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EBADMSG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EBADMSG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EBUSY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EBUSY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ECANCELED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ECANCELED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ECHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ECHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EDEADLK_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EDEADLK));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EDOM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EDOM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EEXIST_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EEXIST));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EFAULT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EFAULT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EFBIG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EFBIG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EINPROGRESS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EINPROGRESS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EINTR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EINTR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EINVAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EINVAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EIO_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EIO));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EISDIR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EISDIR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EMFILE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EMFILE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EMLINK_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EMLINK));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EMSGSIZE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EMSGSIZE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ENAMETOOLONG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ENAMETOOLONG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ENFILE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ENFILE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ENODEV_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ENODEV));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ENOENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ENOENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ENOEXEC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ENOEXEC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ENOLCK_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ENOLCK));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ENOMEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ENOMEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ENOSPC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ENOSPC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ENOSYS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ENOSYS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ENOTDIR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ENOTDIR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ENOTEMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ENOTEMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ENOTSUP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ENOTSUP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ENOTTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ENOTTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ENXIO_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ENXIO));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EPERM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EPERM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EPIPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EPIPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ERANGE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ERANGE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EROFS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EROFS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ESPIPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ESPIPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ESRCH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ESRCH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ETIMEDOUT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ETIMEDOUT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EXDEV_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EXDEV));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_NETWORK_ATTEMPT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_NETWORK_ATTEMPT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ENCODER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ENCODER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_FLUSH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_FLUSH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_WRITE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_WRITE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_NO_INPUT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_NO_INPUT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_BUFFER_FULL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_BUFFER_FULL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_LOAD_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_LOAD_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ENOTSOCK_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ENOTSOCK));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EISCONN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EISCONN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ECONNREFUSED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ECONNREFUSED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_ENETUNREACH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_ENETUNREACH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EADDRINUSE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EADDRINUSE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EALREADY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EALREADY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_EAFNOSUPPORT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_EAFNOSUPPORT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_IO_UNSUPPORTED_PROTOCOL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_IO_UNSUPPORTED_PROTOCOL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_RECURSION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_RECURSION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_PARSE_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_PARSE_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_ENTITY_DEF_MISMATCH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_ENTITY_DEF_MISMATCH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_NO_HREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_NO_HREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_NO_FALLBACK_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_NO_FALLBACK));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_HREF_URI_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_HREF_URI));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_TEXT_FRAGMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_TEXT_FRAGMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_TEXT_DOCUMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_TEXT_DOCUMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_INVALID_CHAR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_INVALID_CHAR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_BUILD_FAILED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_BUILD_FAILED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_UNKNOWN_ENCODING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_UNKNOWN_ENCODING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_MULTIPLE_ROOT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_MULTIPLE_ROOT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_XPTR_FAILED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_XPTR_FAILED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_XPTR_RESULT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_XPTR_RESULT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_INCLUDE_IN_INCLUDE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_INCLUDE_IN_INCLUDE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_FALLBACKS_IN_INCLUDE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_FALLBACKS_IN_INCLUDE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_DEPRECATED_NS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_DEPRECATED_NS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XINCLUDE_FRAGMENT_ID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XINCLUDE_FRAGMENT_ID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CATALOG_MISSING_ATTR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CATALOG_MISSING_ATTR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CATALOG_ENTRY_BROKEN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CATALOG_ENTRY_BROKEN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CATALOG_PREFER_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CATALOG_PREFER_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CATALOG_NOT_CATALOG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CATALOG_NOT_CATALOG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CATALOG_RECURSION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CATALOG_RECURSION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_PREFIX_UNDEFINED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_PREFIX_UNDEFINED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_ATTRFORMDEFAULT_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_ATTRFORMDEFAULT_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_ATTRGRP_NONAME_NOREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_ATTRGRP_NONAME_NOREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_ATTR_NONAME_NOREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_ATTR_NONAME_NOREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_ELEMFORMDEFAULT_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_ELEMFORMDEFAULT_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_ELEM_NONAME_NOREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_ELEM_NONAME_NOREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_EXTENSION_NO_BASE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_EXTENSION_NO_BASE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_FACET_NO_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_FACET_NO_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_FAILED_BUILD_IMPORT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_FAILED_BUILD_IMPORT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_GROUP_NONAME_NOREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_GROUP_NONAME_NOREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_IMPORT_REDEFINE_NSNAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_IMPORT_REDEFINE_NSNAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_INVALID_BOOLEAN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_INVALID_BOOLEAN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_INVALID_ENUM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_INVALID_ENUM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_INVALID_FACET_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_INVALID_FACET));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_INVALID_FACET_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_INVALID_FACET_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_INVALID_MAXOCCURS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_INVALID_MAXOCCURS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_INVALID_MINOCCURS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_INVALID_MINOCCURS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_INVALID_REF_AND_SUBTYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_INVALID_REF_AND_SUBTYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_INVALID_WHITE_SPACE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_INVALID_WHITE_SPACE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_NOATTR_NOREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_NOATTR_NOREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_NOTATION_NO_NAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_NOTATION_NO_NAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_NOTYPE_NOREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_NOTYPE_NOREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_REF_AND_SUBTYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_REF_AND_SUBTYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_RESTRICTION_NONAME_NOREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_RESTRICTION_NONAME_NOREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SIMPLETYPE_NONAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SIMPLETYPE_NONAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_TYPE_AND_SUBTYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_TYPE_AND_SUBTYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_ALL_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_ALL_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_ATTR_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_ATTR_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_BASE_TYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_BASE_TYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_CHOICE_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_CHOICE_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_ELEM_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_ELEM_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_FACET_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_FACET_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_FACET_TYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_FACET_TYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_GROUP_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_GROUP_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_IMPORT_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_IMPORT_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_LIST_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_LIST_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_NOTATION_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_NOTATION_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_REF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_REF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_TYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_TYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_UNION_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_UNION_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_ELEM_DEFAULT_FIXED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_ELEM_DEFAULT_FIXED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_REGEXP_INVALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_REGEXP_INVALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_FAILED_LOAD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_FAILED_LOAD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_NOTHING_TO_PARSE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_NOTHING_TO_PARSE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_NOROOT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_NOROOT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_REDEFINED_GROUP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_REDEFINED_GROUP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_REDEFINED_TYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_REDEFINED_TYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_REDEFINED_ELEMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_REDEFINED_ELEMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_REDEFINED_ATTRGROUP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_REDEFINED_ATTRGROUP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_REDEFINED_ATTR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_REDEFINED_ATTR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_REDEFINED_NOTATION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_REDEFINED_NOTATION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_FAILED_PARSE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_FAILED_PARSE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_PREFIX_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_PREFIX));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_DEF_AND_PREFIX_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_DEF_AND_PREFIX));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_NOT_SCHEMA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_NOT_SCHEMA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNKNOWN_MEMBER_TYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNKNOWN_MEMBER_TYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_INVALID_ATTR_USE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_INVALID_ATTR_USE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_RECURSIVE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_RECURSIVE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_INVALID_ATTR_COMBINATION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_INVALID_ATTR_COMBINATION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_INVALID_ATTR_NAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_INVALID_ATTR_NAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_REF_AND_CONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_REF_AND_CONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_CT_PROPS_CORRECT_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_CT_PROPS_CORRECT_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_CT_PROPS_CORRECT_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_CT_PROPS_CORRECT_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_CT_PROPS_CORRECT_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_CT_PROPS_CORRECT_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_CT_PROPS_CORRECT_4_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_CT_PROPS_CORRECT_4));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_CT_PROPS_CORRECT_5_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_CT_PROPS_CORRECT_5));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_UNION_NOT_EXPRESSIBLE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_UNION_NOT_EXPRESSIBLE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_IMPORT_3_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_IMPORT_3_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_IMPORT_3_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_IMPORT_3_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_CT_EXTENDS_1_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_CT_EXTENDS_1_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_NOROOT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_NOROOT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_UNDECLAREDELEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_UNDECLAREDELEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_NOTTOPLEVEL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_NOTTOPLEVEL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_MISSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_MISSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_WRONGELEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_WRONGELEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_NOTYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_NOTYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_NOROLLBACK_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_NOROLLBACK));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_ISABSTRACT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_ISABSTRACT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_NOTEMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_NOTEMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_ELEMCONT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_ELEMCONT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_HAVEDEFAULT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_HAVEDEFAULT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_NOTNILLABLE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_NOTNILLABLE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_EXTRACONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_EXTRACONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_INVALIDATTR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_INVALIDATTR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_INVALIDELEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_INVALIDELEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_NOTDETERMINIST_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_NOTDETERMINIST));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CONSTRUCT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CONSTRUCT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_INTERNAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_INTERNAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_NOTSIMPLE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_NOTSIMPLE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_ATTRUNKNOWN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_ATTRUNKNOWN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_ATTRINVALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_ATTRINVALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_FACET_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_FACET));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_TYPE_3_1_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_TYPE_3_1_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_TYPE_3_1_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_TYPE_3_1_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_FACET_VALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_FACET_VALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_LENGTH_VALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_LENGTH_VALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_MINLENGTH_VALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_MINLENGTH_VALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_MAXLENGTH_VALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_MAXLENGTH_VALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_MININCLUSIVE_VALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_MININCLUSIVE_VALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_TOTALDIGITS_VALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_TOTALDIGITS_VALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_PATTERN_VALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_PATTERN_VALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ENUMERATION_VALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ENUMERATION_VALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ELT_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ELT_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ELT_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ELT_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ELT_3_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ELT_3_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ELT_3_2_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ELT_3_2_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ELT_3_2_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ELT_3_2_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ELT_4_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ELT_4_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ELT_4_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ELT_4_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ELT_4_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ELT_4_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ELT_5_1_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ELT_5_1_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ELT_5_1_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ELT_5_1_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ELT_5_2_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ELT_5_2_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ELT_5_2_2_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ELT_5_2_2_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ELT_5_2_2_2_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ELT_5_2_2_2_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ELT_5_2_2_2_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ELT_5_2_2_2_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ELT_6_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ELT_6));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ELT_7_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ELT_7));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ATTRIBUTE_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ATTRIBUTE_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ATTRIBUTE_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ATTRIBUTE_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ATTRIBUTE_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ATTRIBUTE_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_ATTRIBUTE_4_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_ATTRIBUTE_4));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_4_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_COMPLEX_TYPE_4));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_ELEMENT_CONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_ELEMENT_CONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_COMPLEX_TYPE_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_AU_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_AU));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_TYPE_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_TYPE_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_TYPE_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_TYPE_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_IDC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_IDC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_CVC_WILDCARD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_CVC_WILDCARD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAV_MISC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAV_MISC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPTR_UNKNOWN_SCHEME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPTR_UNKNOWN_SCHEME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPTR_CHILDSEQ_START_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPTR_CHILDSEQ_START));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPTR_EVAL_FAILED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPTR_EVAL_FAILED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPTR_EXTRA_OBJECTS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_XPTR_EXTRA_OBJECTS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_C14N_CREATE_CTXT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_C14N_CREATE_CTXT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_C14N_REQUIRES_UTF8_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_C14N_REQUIRES_UTF8));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_C14N_CREATE_STACK_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_C14N_CREATE_STACK));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_C14N_INVALID_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_C14N_INVALID_NODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_C14N_UNKNOW_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_C14N_UNKNOW_NODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_C14N_RELATIVE_NAMESPACE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_C14N_RELATIVE_NAMESPACE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FTP_PASV_ANSWER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FTP_PASV_ANSWER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FTP_EPSV_ANSWER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FTP_EPSV_ANSWER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FTP_ACCNT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FTP_ACCNT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_FTP_URL_SYNTAX_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_FTP_URL_SYNTAX));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_HTTP_URL_SYNTAX_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_HTTP_URL_SYNTAX));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_HTTP_USE_IP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_HTTP_USE_IP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_HTTP_UNKNOWN_HOST_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_HTTP_UNKNOWN_HOST));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_SIMPLE_TYPE_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_SIMPLE_TYPE_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_SIMPLE_TYPE_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_SIMPLE_TYPE_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_SIMPLE_TYPE_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_SIMPLE_TYPE_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_SIMPLE_TYPE_4_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_SIMPLE_TYPE_4));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_RESOLVE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_RESOLVE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_ST_PROPS_CORRECT_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_ST_PROPS_CORRECT_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_ST_PROPS_CORRECT_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_ST_PROPS_CORRECT_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_ST_PROPS_CORRECT_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_ST_PROPS_CORRECT_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_1_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_1_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_1_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_1_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_2_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_2_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_3_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_3_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_DERIVED_OK_2_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_DERIVED_OK_2_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ST_DERIVED_OK_2_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ST_DERIVED_OK_2_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_S4S_ELEM_MISSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_S4S_ELEM_MISSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_S4S_ATTR_MISSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_S4S_ATTR_MISSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_S4S_ATTR_INVALID_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_S4S_ATTR_INVALID_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_ELEMENT_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_ELEMENT_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_ELEMENT_2_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_ELEMENT_2_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_ELEMENT_2_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_ELEMENT_2_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_ELEMENT_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_ELEMENT_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_P_PROPS_CORRECT_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_P_PROPS_CORRECT_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_P_PROPS_CORRECT_2_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_P_PROPS_CORRECT_2_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_P_PROPS_CORRECT_2_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_P_PROPS_CORRECT_2_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_E_PROPS_CORRECT_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_E_PROPS_CORRECT_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_E_PROPS_CORRECT_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_E_PROPS_CORRECT_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_E_PROPS_CORRECT_4_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_E_PROPS_CORRECT_4));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_E_PROPS_CORRECT_5_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_E_PROPS_CORRECT_5));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_E_PROPS_CORRECT_6_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_E_PROPS_CORRECT_6));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_INCLUDE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_INCLUDE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_ATTRIBUTE_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_ATTRIBUTE_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_ATTRIBUTE_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_ATTRIBUTE_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_ATTRIBUTE_3_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_ATTRIBUTE_3_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_ATTRIBUTE_3_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_ATTRIBUTE_3_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_ATTRIBUTE_4_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_ATTRIBUTE_4));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_NO_XMLNS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_NO_XMLNS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_NO_XSI_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_NO_XSI));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_VALID_DEFAULT_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_VALID_DEFAULT_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_VALID_DEFAULT_2_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_VALID_DEFAULT_2_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_CVC_SIMPLE_TYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_CVC_SIMPLE_TYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_CT_EXTENDS_1_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_CT_EXTENDS_1_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_IMPORT_1_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_IMPORT_1_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_IMPORT_1_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_IMPORT_1_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_IMPORT_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_IMPORT_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_IMPORT_2_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_IMPORT_2_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_IMPORT_2_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_IMPORT_2_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_INTERNAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_INTERNAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_NOT_DETERMINISTIC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_NOT_DETERMINISTIC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_MG_PROPS_CORRECT_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_MG_PROPS_CORRECT_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_MG_PROPS_CORRECT_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_MG_PROPS_CORRECT_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_CT_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_CT_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_AU_PROPS_CORRECT_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_AU_PROPS_CORRECT_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_A_PROPS_CORRECT_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_A_PROPS_CORRECT_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_C_PROPS_CORRECT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_C_PROPS_CORRECT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_REDEFINE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_REDEFINE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_SRC_IMPORT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_SRC_IMPORT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_WARN_SKIP_SCHEMA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_WARN_SKIP_SCHEMA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_WARN_UNLOCATED_SCHEMA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_WARN_UNLOCATED_SCHEMA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_WARN_ATTR_REDECL_PROH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_WARN_ATTR_REDECL_PROH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_AG_PROPS_CORRECT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_AG_PROPS_CORRECT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_CT_EXTENDS_1_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_CT_EXTENDS_1_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_AU_PROPS_CORRECT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_AU_PROPS_CORRECT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_A_PROPS_CORRECT_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_A_PROPS_CORRECT_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAP_COS_ALL_LIMITED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAP_COS_ALL_LIMITED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMATRONV_ASSERT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMATRONV_ASSERT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMATRONV_REPORT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMATRONV_REPORT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_MODULE_OPEN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_MODULE_OPEN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_MODULE_CLOSE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_MODULE_CLOSE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_FOUND_ELEMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_FOUND_ELEMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_FOUND_ATTRIBUTE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_FOUND_ATTRIBUTE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_FOUND_TEXT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_FOUND_TEXT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_FOUND_CDATA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_FOUND_CDATA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_FOUND_ENTITYREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_FOUND_ENTITYREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_FOUND_ENTITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_FOUND_ENTITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_FOUND_PI_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_FOUND_PI));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_FOUND_COMMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_FOUND_COMMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_FOUND_DOCTYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_FOUND_DOCTYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_FOUND_FRAGMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_FOUND_FRAGMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_FOUND_NOTATION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_FOUND_NOTATION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_UNKNOWN_NODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_UNKNOWN_NODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_ENTITY_TYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_ENTITY_TYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NO_PARENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NO_PARENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NO_DOC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NO_DOC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NO_NAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NO_NAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NO_ELEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NO_ELEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_WRONG_DOC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_WRONG_DOC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NO_PREV_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NO_PREV));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_WRONG_PREV_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_WRONG_PREV));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NO_NEXT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NO_NEXT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_WRONG_NEXT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_WRONG_NEXT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NOT_DTD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NOT_DTD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NOT_ATTR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NOT_ATTR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NOT_ATTR_DECL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NOT_ATTR_DECL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NOT_ELEM_DECL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NOT_ELEM_DECL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NOT_ENTITY_DECL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NOT_ENTITY_DECL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NOT_NS_DECL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NOT_NS_DECL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NO_HREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NO_HREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_WRONG_PARENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_WRONG_PARENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NS_SCOPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NS_SCOPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NS_ANCESTOR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NS_ANCESTOR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NOT_UTF8_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NOT_UTF8));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NO_DICT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NO_DICT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NOT_NCNAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NOT_NCNAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_OUTSIDE_DICT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_OUTSIDE_DICT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_WRONG_NAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_WRONG_NAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHECK_NAME_NOT_NULL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHECK_NAME_NOT_NULL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_I18N_NO_NAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_I18N_NO_NAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_I18N_NO_HANDLER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_I18N_NO_HANDLER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_I18N_EXCESS_HANDLER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_I18N_EXCESS_HANDLER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_I18N_CONV_FAILED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_I18N_CONV_FAILED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_I18N_NO_OUTPUT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_I18N_NO_OUTPUT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_BUF_OVERFLOW_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_BUF_OVERFLOW));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap___xmlLastError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlError *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlLastError.");
  
  result = (xmlError *)__xmlLastError();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlError, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlGenericError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlGenericErrorFunc *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlGenericError.");
  
  result = (xmlGenericErrorFunc *)__xmlGenericError();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_f_p_void_p_q_const__char_v_______void, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlGenericErrorContext(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void **result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlGenericErrorContext.");
  
  result = (void **)__xmlGenericErrorContext();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_void, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlStructuredError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlStructuredErrorFunc *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlStructuredError.");
  
  result = (xmlStructuredErrorFunc *)__xmlStructuredError();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_f_p_void_p_q_const___xmlError__void, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlStructuredErrorContext(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void **result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlStructuredErrorContext.");
  
  result = (void **)__xmlStructuredErrorContext();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_void, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSetGenericErrorFunc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlGenericErrorFunc arg2 = (xmlGenericErrorFunc) 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSetGenericErrorFunc.");
  
  arg1 = getSwigCObjectPtr(args[0]);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlSetGenericErrorFunc" "', argument " "2"" of type '" "xmlGenericErrorFunc""'"); 
      }
    }
  }
  xmlSetGenericErrorFunc(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefSetGenericErrorFunc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlGenericErrorFunc arg2 = (xmlGenericErrorFunc) 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefSetGenericErrorFunc.");
  
  arg1 = getSwigCObjectPtr(args[0]);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlThrDefSetGenericErrorFunc" "', argument " "2"" of type '" "xmlGenericErrorFunc""'"); 
      }
    }
  }
  xmlThrDefSetGenericErrorFunc(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_initGenericErrorDefaultFunc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlGenericErrorFunc *arg1 = (xmlGenericErrorFunc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_initGenericErrorDefaultFunc.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_p_f_p_void_p_q_const__char_v_______void, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "initGenericErrorDefaultFunc" "', argument " "1"" of type '" "xmlGenericErrorFunc *""'"); 
  }
  arg1 = reinterpret_cast< xmlGenericErrorFunc * >(argp1);initGenericErrorDefaultFunc(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSetStructuredErrorFunc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlStructuredErrorFunc arg2 = (xmlStructuredErrorFunc) 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSetStructuredErrorFunc.");
  
  arg1 = getSwigCObjectPtr(args[0]);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const___xmlError__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlSetStructuredErrorFunc" "', argument " "2"" of type '" "xmlStructuredErrorFunc""'"); 
      }
    }
  }
  xmlSetStructuredErrorFunc(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefSetStructuredErrorFunc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlStructuredErrorFunc arg2 = (xmlStructuredErrorFunc) 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefSetStructuredErrorFunc.");
  
  arg1 = getSwigCObjectPtr(args[0]);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const___xmlError__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlThrDefSetStructuredErrorFunc" "', argument " "2"" of type '" "xmlStructuredErrorFunc""'"); 
      }
    }
  }
  xmlThrDefSetStructuredErrorFunc(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserError.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParserError" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }xmlParserError(arg1,(char const *)arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserWarning(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserWarning.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParserWarning" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }xmlParserWarning(arg1,(char const *)arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserValidityError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserValidityError.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParserValidityError" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }xmlParserValidityError(arg1,(char const *)arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserValidityWarning(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserValidityWarning.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParserValidityWarning" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }xmlParserValidityWarning(arg1,(char const *)arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserPrintFileInfo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserPrintFileInfo.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserPrintFileInfo" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);xmlParserPrintFileInfo(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserPrintFileContext(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserPrintFileContext.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserPrintFileContext" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);xmlParserPrintFileContext(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFormatError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlError *arg1 = (xmlError *) 0 ;
  xmlGenericErrorFunc arg2 = (xmlGenericErrorFunc) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFormatError.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFormatError" "', argument " "1"" of type '" "xmlError const *""'"); 
  }
  arg1 = reinterpret_cast< xmlError * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlFormatError" "', argument " "2"" of type '" "xmlGenericErrorFunc""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);xmlFormatError((_xmlError const *)arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetLastError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlError *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetLastError.");
  
  result = (xmlError *)xmlGetLastError();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlError, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlResetLastError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlResetLastError.");
  
  xmlResetLastError();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCtxtGetLastError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlError *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCtxtGetLastError.");
  
  arg1 = getSwigCObjectPtr(args[0]);result = (xmlError *)xmlCtxtGetLastError(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlError, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCtxtResetLastError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCtxtResetLastError.");
  
  arg1 = getSwigCObjectPtr(args[0]);xmlCtxtResetLastError(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlResetError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlErrorPtr arg1 = (xmlErrorPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlResetError.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlResetError" "', argument " "1"" of type '" "xmlErrorPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlErrorPtr >(argp1);xmlResetError(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlError *arg1 = (xmlError *) 0 ;
  xmlErrorPtr arg2 = (xmlErrorPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyError.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCopyError" "', argument " "1"" of type '" "xmlError const *""'"); 
  }
  arg1 = reinterpret_cast< xmlError * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCopyError" "', argument " "2"" of type '" "xmlErrorPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlErrorPtr >(argp2);result = (int)xmlCopyError((_xmlError const *)arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListCreate(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListDeallocator arg1 = (xmlListDeallocator) 0 ;
  xmlListDataCompare arg2 = (xmlListDataCompare) 0 ;
  xmlListPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListCreate.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p__xmlLink__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlListCreate" "', argument " "1"" of type '" "xmlListDeallocator""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void_p_q_const__void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlListCreate" "', argument " "2"" of type '" "xmlListDataCompare""'"); 
      }
    }
  }
  result = (xmlListPtr)xmlListCreate(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlList, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListDelete(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListDelete.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListDelete" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);xmlListDelete(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListSearch(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListSearch.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListSearch" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);arg2 = getSwigCObjectPtr(args[1]);result = (void *)xmlListSearch(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListReverseSearch(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListReverseSearch.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListReverseSearch" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);arg2 = getSwigCObjectPtr(args[1]);result = (void *)xmlListReverseSearch(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListInsert(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListInsert.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListInsert" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);arg2 = getSwigCObjectPtr(args[1]);result = (int)xmlListInsert(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListAppend(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListAppend.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListAppend" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);arg2 = getSwigCObjectPtr(args[1]);result = (int)xmlListAppend(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListRemoveFirst(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListRemoveFirst.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListRemoveFirst" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);arg2 = getSwigCObjectPtr(args[1]);result = (int)xmlListRemoveFirst(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListRemoveLast(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListRemoveLast.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListRemoveLast" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);arg2 = getSwigCObjectPtr(args[1]);result = (int)xmlListRemoveLast(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListRemoveAll(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListRemoveAll.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListRemoveAll" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);arg2 = getSwigCObjectPtr(args[1]);result = (int)xmlListRemoveAll(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListClear(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListClear.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListClear" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);xmlListClear(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListEmpty(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListEmpty.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListEmpty" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);result = (int)xmlListEmpty(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListFront(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlLinkPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListFront.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListFront" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);result = (xmlLinkPtr)xmlListFront(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlLink, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListEnd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlLinkPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListEnd.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListEnd" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);result = (xmlLinkPtr)xmlListEnd(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlLink, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListSize(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListSize.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListSize" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);result = (int)xmlListSize(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListPopFront(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListPopFront.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListPopFront" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);xmlListPopFront(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListPopBack(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListPopBack.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListPopBack" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);xmlListPopBack(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListPushFront(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListPushFront.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListPushFront" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);arg2 = getSwigCObjectPtr(args[1]);result = (int)xmlListPushFront(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListPushBack(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListPushBack.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListPushBack" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);arg2 = getSwigCObjectPtr(args[1]);result = (int)xmlListPushBack(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListReverse(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListReverse.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListReverse" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);xmlListReverse(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListSort(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListSort.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListSort" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);xmlListSort(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListWalk(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  xmlListWalker arg2 = (xmlListWalker) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListWalk.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListWalk" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlListWalk" "', argument " "2"" of type '" "xmlListWalker""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);xmlListWalk(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListReverseWalk(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  xmlListWalker arg2 = (xmlListWalker) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListReverseWalk.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListReverseWalk" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_q_const__void_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlListReverseWalk" "', argument " "2"" of type '" "xmlListWalker""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);xmlListReverseWalk(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListMerge(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  xmlListPtr arg2 = (xmlListPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListMerge.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListMerge" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlListMerge" "', argument " "2"" of type '" "xmlListPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlListPtr >(argp2);xmlListMerge(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListDup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlListPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListDup.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListDup" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);result = (xmlListPtr)xmlListDup(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlList, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlListCopy(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlListPtr arg1 = (xmlListPtr) 0 ;
  xmlListPtr arg2 = (xmlListPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlListCopy.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlListCopy" "', argument " "1"" of type '" "xmlListPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlListPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlList, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlListCopy" "', argument " "2"" of type '" "xmlListPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlListPtr >(argp2);result = (int)xmlListCopy(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlLinkGetData(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlLinkPtr arg1 = (xmlLinkPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlLinkGetData.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlLink, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlLinkGetData" "', argument " "1"" of type '" "xmlLinkPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlLinkPtr >(argp1);result = (void *)xmlLinkGetData(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewAutomata(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewAutomata.");
  
  result = (xmlAutomataPtr)xmlNewAutomata();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAutomata, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeAutomata(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeAutomata.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeAutomata" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);xmlFreeAutomata(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAutomataGetInitState(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlAutomataStatePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAutomataGetInitState.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAutomataGetInitState" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);result = (xmlAutomataStatePtr)xmlAutomataGetInitState(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAutomataSetFinalState(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  xmlAutomataStatePtr arg2 = (xmlAutomataStatePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAutomataSetFinalState.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAutomataSetFinalState" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlAutomataSetFinalState" "', argument " "2"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlAutomataStatePtr >(argp2);result = (int)xmlAutomataSetFinalState(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAutomataNewState(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlAutomataStatePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAutomataNewState.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAutomataNewState" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);result = (xmlAutomataStatePtr)xmlAutomataNewState(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAutomataNewTransition(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  xmlAutomataStatePtr arg2 = (xmlAutomataStatePtr) 0 ;
  xmlAutomataStatePtr arg3 = (xmlAutomataStatePtr) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  void *arg5 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  xmlAutomataStatePtr result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAutomataNewTransition.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAutomataNewTransition" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlAutomataNewTransition" "', argument " "2"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlAutomataStatePtr >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlAutomataNewTransition" "', argument " "3"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg3 = reinterpret_cast< xmlAutomataStatePtr >(argp3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlAutomataNewTransition" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }arg5 = getSwigCObjectPtr(args[4]);result = (xmlAutomataStatePtr)xmlAutomataNewTransition(arg1,arg2,arg3,(unsigned char const *)arg4,arg5);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAutomataNewTransition2(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  xmlAutomataStatePtr arg2 = (xmlAutomataStatePtr) 0 ;
  xmlAutomataStatePtr arg3 = (xmlAutomataStatePtr) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  void *arg6 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  xmlAutomataStatePtr result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAutomataNewTransition2.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAutomataNewTransition2" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlAutomataNewTransition2" "', argument " "2"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlAutomataStatePtr >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlAutomataNewTransition2" "', argument " "3"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg3 = reinterpret_cast< xmlAutomataStatePtr >(argp3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlAutomataNewTransition2" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlAutomataNewTransition2" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }arg6 = getSwigCObjectPtr(args[5]);result = (xmlAutomataStatePtr)xmlAutomataNewTransition2(arg1,arg2,arg3,(unsigned char const *)arg4,(unsigned char const *)arg5,arg6);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAutomataNewNegTrans(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  xmlAutomataStatePtr arg2 = (xmlAutomataStatePtr) 0 ;
  xmlAutomataStatePtr arg3 = (xmlAutomataStatePtr) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  void *arg6 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  xmlAutomataStatePtr result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAutomataNewNegTrans.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAutomataNewNegTrans" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlAutomataNewNegTrans" "', argument " "2"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlAutomataStatePtr >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlAutomataNewNegTrans" "', argument " "3"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg3 = reinterpret_cast< xmlAutomataStatePtr >(argp3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlAutomataNewNegTrans" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlAutomataNewNegTrans" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }arg6 = getSwigCObjectPtr(args[5]);result = (xmlAutomataStatePtr)xmlAutomataNewNegTrans(arg1,arg2,arg3,(unsigned char const *)arg4,(unsigned char const *)arg5,arg6);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAutomataNewCountTrans(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  xmlAutomataStatePtr arg2 = (xmlAutomataStatePtr) 0 ;
  xmlAutomataStatePtr arg3 = (xmlAutomataStatePtr) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int arg5 ;
  int arg6 ;
  void *arg7 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  xmlAutomataStatePtr result;
  
  if (args.Length() < 7 || args.Length() > 7) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAutomataNewCountTrans.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAutomataNewCountTrans" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlAutomataNewCountTrans" "', argument " "2"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlAutomataStatePtr >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlAutomataNewCountTrans" "', argument " "3"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg3 = reinterpret_cast< xmlAutomataStatePtr >(argp3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlAutomataNewCountTrans" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlAutomataNewCountTrans" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);ecode6 = SWIG_AsVal_int(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xmlAutomataNewCountTrans" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);arg7 = getSwigCObjectPtr(args[6]);result = (xmlAutomataStatePtr)xmlAutomataNewCountTrans(arg1,arg2,arg3,(unsigned char const *)arg4,arg5,arg6,arg7);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAutomataNewCountTrans2(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  xmlAutomataStatePtr arg2 = (xmlAutomataStatePtr) 0 ;
  xmlAutomataStatePtr arg3 = (xmlAutomataStatePtr) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  int arg6 ;
  int arg7 ;
  void *arg8 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  xmlAutomataStatePtr result;
  
  if (args.Length() < 8 || args.Length() > 8) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAutomataNewCountTrans2.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAutomataNewCountTrans2" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlAutomataNewCountTrans2" "', argument " "2"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlAutomataStatePtr >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlAutomataNewCountTrans2" "', argument " "3"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg3 = reinterpret_cast< xmlAutomataStatePtr >(argp3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlAutomataNewCountTrans2" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlAutomataNewCountTrans2" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }ecode6 = SWIG_AsVal_int(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xmlAutomataNewCountTrans2" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);ecode7 = SWIG_AsVal_int(args[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "xmlAutomataNewCountTrans2" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);arg8 = getSwigCObjectPtr(args[7]);result = (xmlAutomataStatePtr)xmlAutomataNewCountTrans2(arg1,arg2,arg3,(unsigned char const *)arg4,(unsigned char const *)arg5,arg6,arg7,arg8);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  
  
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAutomataNewOnceTrans(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  xmlAutomataStatePtr arg2 = (xmlAutomataStatePtr) 0 ;
  xmlAutomataStatePtr arg3 = (xmlAutomataStatePtr) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int arg5 ;
  int arg6 ;
  void *arg7 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  xmlAutomataStatePtr result;
  
  if (args.Length() < 7 || args.Length() > 7) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAutomataNewOnceTrans.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAutomataNewOnceTrans" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlAutomataNewOnceTrans" "', argument " "2"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlAutomataStatePtr >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlAutomataNewOnceTrans" "', argument " "3"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg3 = reinterpret_cast< xmlAutomataStatePtr >(argp3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlAutomataNewOnceTrans" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlAutomataNewOnceTrans" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);ecode6 = SWIG_AsVal_int(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xmlAutomataNewOnceTrans" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);arg7 = getSwigCObjectPtr(args[6]);result = (xmlAutomataStatePtr)xmlAutomataNewOnceTrans(arg1,arg2,arg3,(unsigned char const *)arg4,arg5,arg6,arg7);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAutomataNewOnceTrans2(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  xmlAutomataStatePtr arg2 = (xmlAutomataStatePtr) 0 ;
  xmlAutomataStatePtr arg3 = (xmlAutomataStatePtr) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  int arg6 ;
  int arg7 ;
  void *arg8 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  xmlAutomataStatePtr result;
  
  if (args.Length() < 8 || args.Length() > 8) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAutomataNewOnceTrans2.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAutomataNewOnceTrans2" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlAutomataNewOnceTrans2" "', argument " "2"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlAutomataStatePtr >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlAutomataNewOnceTrans2" "', argument " "3"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg3 = reinterpret_cast< xmlAutomataStatePtr >(argp3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlAutomataNewOnceTrans2" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlAutomataNewOnceTrans2" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }ecode6 = SWIG_AsVal_int(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xmlAutomataNewOnceTrans2" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);ecode7 = SWIG_AsVal_int(args[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "xmlAutomataNewOnceTrans2" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);arg8 = getSwigCObjectPtr(args[7]);result = (xmlAutomataStatePtr)xmlAutomataNewOnceTrans2(arg1,arg2,arg3,(unsigned char const *)arg4,(unsigned char const *)arg5,arg6,arg7,arg8);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  
  
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAutomataNewAllTrans(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  xmlAutomataStatePtr arg2 = (xmlAutomataStatePtr) 0 ;
  xmlAutomataStatePtr arg3 = (xmlAutomataStatePtr) 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 ;
  xmlAutomataStatePtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAutomataNewAllTrans.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAutomataNewAllTrans" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlAutomataNewAllTrans" "', argument " "2"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlAutomataStatePtr >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlAutomataNewAllTrans" "', argument " "3"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg3 = reinterpret_cast< xmlAutomataStatePtr >(argp3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlAutomataNewAllTrans" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (xmlAutomataStatePtr)xmlAutomataNewAllTrans(arg1,arg2,arg3,arg4);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAutomataNewEpsilon(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  xmlAutomataStatePtr arg2 = (xmlAutomataStatePtr) 0 ;
  xmlAutomataStatePtr arg3 = (xmlAutomataStatePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  xmlAutomataStatePtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAutomataNewEpsilon.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAutomataNewEpsilon" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlAutomataNewEpsilon" "', argument " "2"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlAutomataStatePtr >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlAutomataNewEpsilon" "', argument " "3"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg3 = reinterpret_cast< xmlAutomataStatePtr >(argp3);result = (xmlAutomataStatePtr)xmlAutomataNewEpsilon(arg1,arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAutomataNewCountedTrans(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  xmlAutomataStatePtr arg2 = (xmlAutomataStatePtr) 0 ;
  xmlAutomataStatePtr arg3 = (xmlAutomataStatePtr) 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 ;
  xmlAutomataStatePtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAutomataNewCountedTrans.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAutomataNewCountedTrans" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlAutomataNewCountedTrans" "', argument " "2"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlAutomataStatePtr >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlAutomataNewCountedTrans" "', argument " "3"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg3 = reinterpret_cast< xmlAutomataStatePtr >(argp3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlAutomataNewCountedTrans" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (xmlAutomataStatePtr)xmlAutomataNewCountedTrans(arg1,arg2,arg3,arg4);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAutomataNewCounterTrans(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  xmlAutomataStatePtr arg2 = (xmlAutomataStatePtr) 0 ;
  xmlAutomataStatePtr arg3 = (xmlAutomataStatePtr) 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 ;
  xmlAutomataStatePtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAutomataNewCounterTrans.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAutomataNewCounterTrans" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlAutomataNewCounterTrans" "', argument " "2"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlAutomataStatePtr >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlAutomataNewCounterTrans" "', argument " "3"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg3 = reinterpret_cast< xmlAutomataStatePtr >(argp3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlAutomataNewCounterTrans" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (xmlAutomataStatePtr)xmlAutomataNewCounterTrans(arg1,arg2,arg3,arg4);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAutomataNewCounter(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAutomataNewCounter.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAutomataNewCounter" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlAutomataNewCounter" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlAutomataNewCounter" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlAutomataNewCounter(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAutomataCompile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlRegexp *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAutomataCompile.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAutomataCompile" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);result = (_xmlRegexp *)xmlAutomataCompile(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlRegexp, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAutomataIsDeterminist(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAutomataPtr arg1 = (xmlAutomataPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAutomataIsDeterminist.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlAutomata, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAutomataIsDeterminist" "', argument " "1"" of type '" "xmlAutomataPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAutomataPtr >(argp1);result = (int)xmlAutomataIsDeterminist(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap__xmlValidCtxt_userData_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_userData_set" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->userData = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlValidCtxt_userData_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_userData_get" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);result = (void *) ((arg1)->userData);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlValidCtxt_error_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  xmlValidityErrorFunc arg2 = (xmlValidityErrorFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_error_set" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlValidCtxt_error_set" "', argument " "2"" of type '" "xmlValidityErrorFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->error = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlValidCtxt_error_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlValidityErrorFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_error_get" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);result = (xmlValidityErrorFunc) ((arg1)->error);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlValidCtxt_warning_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  xmlValidityWarningFunc arg2 = (xmlValidityWarningFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_warning_set" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlValidCtxt_warning_set" "', argument " "2"" of type '" "xmlValidityWarningFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->warning = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlValidCtxt_warning_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlValidityWarningFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_warning_get" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);result = (xmlValidityWarningFunc) ((arg1)->warning);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlValidCtxt_node_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_node_set" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlValidCtxt_node_set', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (arg1) (arg1)->node = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlValidCtxt_node_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_node_get" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);result = (xmlNodePtr) ((arg1)->node);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlValidCtxt_nodeNr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_nodeNr_set" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlValidCtxt_nodeNr_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nodeNr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlValidCtxt_nodeNr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_nodeNr_get" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);result = (int) ((arg1)->nodeNr);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlValidCtxt_nodeMax_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_nodeMax_set" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlValidCtxt_nodeMax_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nodeMax = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlValidCtxt_nodeMax_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_nodeMax_get" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);result = (int) ((arg1)->nodeMax);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlValidCtxt_nodeTab_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  xmlNodePtr *arg2 = (xmlNodePtr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_nodeTab_set" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_p__xmlNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlValidCtxt_nodeTab_set" "', argument " "2"" of type '" "xmlNodePtr *""'"); 
  }
  arg2 = reinterpret_cast< xmlNodePtr * >(argp2);if (arg1) (arg1)->nodeTab = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlValidCtxt_nodeTab_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_nodeTab_get" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);result = (xmlNodePtr *) ((arg1)->nodeTab);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__xmlNode, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlValidCtxt_flags_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_flags_set" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlValidCtxt_flags_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);if (arg1) (arg1)->flags = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlValidCtxt_flags_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_flags_get" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);result = (unsigned int) ((arg1)->flags);
  jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlValidCtxt_doc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_doc_set" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlValidCtxt_doc_set', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;if (arg1) (arg1)->doc = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlValidCtxt_doc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlDocPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_doc_get" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);result = (xmlDocPtr) ((arg1)->doc);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlValidCtxt_valid_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_valid_set" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlValidCtxt_valid_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->valid = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlValidCtxt_valid_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_valid_get" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);result = (int) ((arg1)->valid);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlValidCtxt_vstate_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  xmlValidState *arg2 = (xmlValidState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_vstate_set" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlValidState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlValidCtxt_vstate_set" "', argument " "2"" of type '" "xmlValidState *""'"); 
  }
  arg2 = reinterpret_cast< xmlValidState * >(argp2);if (arg1) (arg1)->vstate = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlValidCtxt_vstate_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlValidState *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_vstate_get" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);result = (xmlValidState *) ((arg1)->vstate);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlValidState, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlValidCtxt_vstateNr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_vstateNr_set" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlValidCtxt_vstateNr_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->vstateNr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlValidCtxt_vstateNr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_vstateNr_get" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);result = (int) ((arg1)->vstateNr);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlValidCtxt_vstateMax_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_vstateMax_set" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlValidCtxt_vstateMax_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->vstateMax = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlValidCtxt_vstateMax_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_vstateMax_get" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);result = (int) ((arg1)->vstateMax);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlValidCtxt_vstateTab_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  xmlValidState *arg2 = (xmlValidState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_vstateTab_set" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlValidState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlValidCtxt_vstateTab_set" "', argument " "2"" of type '" "xmlValidState *""'"); 
  }
  arg2 = reinterpret_cast< xmlValidState * >(argp2);if (arg1) (arg1)->vstateTab = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlValidCtxt_vstateTab_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlValidState *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_vstateTab_get" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);result = (xmlValidState *) ((arg1)->vstateTab);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlValidState, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlValidCtxt_am_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  xmlAutomataPtr arg2 = (xmlAutomataPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_am_set" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlAutomata, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlValidCtxt_am_set" "', argument " "2"" of type '" "xmlAutomataPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlAutomataPtr >(argp2);if (arg1) (arg1)->am = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlValidCtxt_am_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlAutomataPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_am_get" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);result = (xmlAutomataPtr) ((arg1)->am);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAutomata, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlValidCtxt_state_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  xmlAutomataStatePtr arg2 = (xmlAutomataStatePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_state_set" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlAutomataState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlValidCtxt_state_set" "', argument " "2"" of type '" "xmlAutomataStatePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlAutomataStatePtr >(argp2);if (arg1) (arg1)->state = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlValidCtxt_state_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlValidCtxt *arg1 = (_xmlValidCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlAutomataStatePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlValidCtxt_state_get" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);result = (xmlAutomataStatePtr) ((arg1)->state);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAutomataState, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlValidCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlValidCtxt *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlValidCtxt.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlValidCtxt.");
  result = (_xmlValidCtxt *)new _xmlValidCtxt();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlValidCtxt, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlValidCtxt(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlValidCtxt * arg1 = (_xmlValidCtxt *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap_xmlAddNotationDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDtdPtr arg2 = (xmlDtdPtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  xmlNotationPtr result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAddNotationDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAddNotationDecl" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlAddNotationDecl', argument 2 of type 'xmlDtdPtr'"); 
  }
  arg2 = (xmlDtdPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlAddNotationDecl" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlAddNotationDecl" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlAddNotationDecl" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }result = (xmlNotationPtr)xmlAddNotationDecl(arg1,arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,(unsigned char const *)arg5);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlNotation, 0 |  0 );
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyNotationTable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNotationTablePtr arg1 = (xmlNotationTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNotationTablePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyNotationTable.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCopyNotationTable" "', argument " "1"" of type '" "xmlNotationTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNotationTablePtr >(argp1);result = (xmlNotationTablePtr)xmlCopyNotationTable(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeNotationTable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNotationTablePtr arg1 = (xmlNotationTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeNotationTable.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeNotationTable" "', argument " "1"" of type '" "xmlNotationTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNotationTablePtr >(argp1);xmlFreeNotationTable(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDumpNotationDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlNotationPtr arg2 = (xmlNotationPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDumpNotationDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDumpNotationDecl" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlNotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlDumpNotationDecl" "', argument " "2"" of type '" "xmlNotationPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlNotationPtr >(argp2);xmlDumpNotationDecl(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDumpNotationTable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlNotationTablePtr arg2 = (xmlNotationTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDumpNotationTable.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDumpNotationTable" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlDumpNotationTable" "', argument " "2"" of type '" "xmlNotationTablePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlNotationTablePtr >(argp2);xmlDumpNotationTable(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewElementContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlElementContentType arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlElementContentPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewElementContent.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewElementContent" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlNewElementContent" "', argument " "2"" of type '" "xmlElementContentType""'");
  } 
  arg2 = static_cast< xmlElementContentType >(val2);result = (xmlElementContentPtr)xmlNewElementContent((unsigned char const *)arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlElementContent, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyElementContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlElementContentPtr arg1 = (xmlElementContentPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlElementContentPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyElementContent.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCopyElementContent" "', argument " "1"" of type '" "xmlElementContentPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlElementContentPtr >(argp1);result = (xmlElementContentPtr)xmlCopyElementContent(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlElementContent, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeElementContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlElementContentPtr arg1 = (xmlElementContentPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeElementContent.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeElementContent" "', argument " "1"" of type '" "xmlElementContentPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlElementContentPtr >(argp1);xmlFreeElementContent(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewDocElementContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlElementContentType arg3 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlElementContentPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewDocElementContent.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewDocElementContent', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewDocElementContent" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlNewDocElementContent" "', argument " "3"" of type '" "xmlElementContentType""'");
  } 
  arg3 = static_cast< xmlElementContentType >(val3);result = (xmlElementContentPtr)xmlNewDocElementContent(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlElementContent, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyDocElementContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlElementContentPtr arg2 = (xmlElementContentPtr) 0 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlElementContentPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyDocElementContent.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlCopyDocElementContent', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCopyDocElementContent" "', argument " "2"" of type '" "xmlElementContentPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlElementContentPtr >(argp2);result = (xmlElementContentPtr)xmlCopyDocElementContent(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlElementContent, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeDocElementContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlElementContentPtr arg2 = (xmlElementContentPtr) 0 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeDocElementContent.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlFreeDocElementContent', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlFreeDocElementContent" "', argument " "2"" of type '" "xmlElementContentPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlElementContentPtr >(argp2);xmlFreeDocElementContent(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSnprintfElementContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  xmlElementContentPtr arg3 = (xmlElementContentPtr) 0 ;
  int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSnprintfElementContent.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSnprintfElementContent" "', argument " "1"" of type '" "char *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlSnprintfElementContent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSnprintfElementContent" "', argument " "3"" of type '" "xmlElementContentPtr""'"); 
  }
  arg3 = reinterpret_cast< xmlElementContentPtr >(argp3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlSnprintfElementContent" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);xmlSnprintfElementContent(arg1,arg2,arg3,arg4);
  jsresult = SWIGV8_UNDEFINED();
  // free(arg1);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSprintfElementContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  xmlElementContentPtr arg2 = (xmlElementContentPtr) 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSprintfElementContent.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSprintfElementContent" "', argument " "1"" of type '" "char *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSprintfElementContent" "', argument " "2"" of type '" "xmlElementContentPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlElementContentPtr >(argp2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSprintfElementContent" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);xmlSprintfElementContent(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  // free(arg1);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAddElementDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDtdPtr arg2 = (xmlDtdPtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlElementTypeVal arg4 ;
  xmlElementContentPtr arg5 = (xmlElementContentPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  xmlElementPtr result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAddElementDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAddElementDecl" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlAddElementDecl', argument 2 of type 'xmlDtdPtr'"); 
  }
  arg2 = (xmlDtdPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlAddElementDecl" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlAddElementDecl" "', argument " "4"" of type '" "xmlElementTypeVal""'");
  } 
  arg4 = static_cast< xmlElementTypeVal >(val4);res5 = SWIG_ConvertPtr(args[4], &argp5,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlAddElementDecl" "', argument " "5"" of type '" "xmlElementContentPtr""'"); 
  }
  arg5 = reinterpret_cast< xmlElementContentPtr >(argp5);result = (xmlElementPtr)xmlAddElementDecl(arg1,arg2,(unsigned char const *)arg3,arg4,arg5);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlElement);
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyElementTable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlElementTablePtr arg1 = (xmlElementTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlElementTablePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyElementTable.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCopyElementTable" "', argument " "1"" of type '" "xmlElementTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlElementTablePtr >(argp1);result = (xmlElementTablePtr)xmlCopyElementTable(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeElementTable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlElementTablePtr arg1 = (xmlElementTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeElementTable.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeElementTable" "', argument " "1"" of type '" "xmlElementTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlElementTablePtr >(argp1);xmlFreeElementTable(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDumpElementTable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlElementTablePtr arg2 = (xmlElementTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDumpElementTable.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDumpElementTable" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlDumpElementTable" "', argument " "2"" of type '" "xmlElementTablePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlElementTablePtr >(argp2);xmlDumpElementTable(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDumpElementDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlElementPtr arg2 = (xmlElementPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDumpElementDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDumpElementDecl" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlDumpElementDecl', argument 2 of type 'xmlElementPtr'"); 
  }
  arg2 = (xmlElementPtr) arg20;xmlDumpElementDecl(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCreateEnumeration(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlEnumerationPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCreateEnumeration.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCreateEnumeration" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlEnumerationPtr)xmlCreateEnumeration((unsigned char const *)arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlEnumeration, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeEnumeration(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlEnumerationPtr arg1 = (xmlEnumerationPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeEnumeration.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlEnumeration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeEnumeration" "', argument " "1"" of type '" "xmlEnumerationPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlEnumerationPtr >(argp1);xmlFreeEnumeration(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyEnumeration(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlEnumerationPtr arg1 = (xmlEnumerationPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlEnumerationPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyEnumeration.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlEnumeration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCopyEnumeration" "', argument " "1"" of type '" "xmlEnumerationPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlEnumerationPtr >(argp1);result = (xmlEnumerationPtr)xmlCopyEnumeration(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlEnumeration, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAddAttributeDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDtdPtr arg2 = (xmlDtdPtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  xmlAttributeType arg6 ;
  xmlAttributeDefault arg7 ;
  xmlChar *arg8 = (xmlChar *) 0 ;
  xmlEnumerationPtr arg9 = (xmlEnumerationPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int res8 ;
  char *buf8 = 0 ;
  size_t size8 = 0 ;
  int alloc8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  xmlAttributePtr result;
  
  if (args.Length() < 9 || args.Length() > 9) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAddAttributeDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAddAttributeDecl" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlAddAttributeDecl', argument 2 of type 'xmlDtdPtr'"); 
  }
  arg2 = (xmlDtdPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlAddAttributeDecl" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlAddAttributeDecl" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlAddAttributeDecl" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }ecode6 = SWIG_AsVal_int(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xmlAddAttributeDecl" "', argument " "6"" of type '" "xmlAttributeType""'");
  } 
  arg6 = static_cast< xmlAttributeType >(val6);ecode7 = SWIG_AsVal_int(args[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "xmlAddAttributeDecl" "', argument " "7"" of type '" "xmlAttributeDefault""'");
  } 
  arg7 = static_cast< xmlAttributeDefault >(val7);if (args[7]->IsNull()) {
    arg8 = NULL;
  } else {
    res8 = SWIG_AsCharPtrAndSize(args[7], &buf8, &size8, &alloc8);
    
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "xmlAddAttributeDecl" "', argument " "8"" of type '" "xmlChar const *""'");
    }
    
    arg8 = reinterpret_cast< xmlChar * >(buf8);
  }res9 = SWIG_ConvertPtr(args[8], &argp9,SWIGTYPE_p__xmlEnumeration, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "xmlAddAttributeDecl" "', argument " "9"" of type '" "xmlEnumerationPtr""'"); 
  }
  arg9 = reinterpret_cast< xmlEnumerationPtr >(argp9);result = (xmlAttributePtr)xmlAddAttributeDecl(arg1,arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,(unsigned char const *)arg5,arg6,arg7,(unsigned char const *)arg8,arg9);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAttribute, 0 |  0 );
  
  
  
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyAttributeTable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAttributeTablePtr arg1 = (xmlAttributeTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlAttributeTablePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyAttributeTable.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCopyAttributeTable" "', argument " "1"" of type '" "xmlAttributeTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAttributeTablePtr >(argp1);result = (xmlAttributeTablePtr)xmlCopyAttributeTable(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeAttributeTable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAttributeTablePtr arg1 = (xmlAttributeTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeAttributeTable.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeAttributeTable" "', argument " "1"" of type '" "xmlAttributeTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlAttributeTablePtr >(argp1);xmlFreeAttributeTable(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDumpAttributeTable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlAttributeTablePtr arg2 = (xmlAttributeTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDumpAttributeTable.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDumpAttributeTable" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlDumpAttributeTable" "', argument " "2"" of type '" "xmlAttributeTablePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlAttributeTablePtr >(argp2);xmlDumpAttributeTable(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDumpAttributeDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlAttributePtr arg2 = (xmlAttributePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDumpAttributeDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDumpAttributeDecl" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlDumpAttributeDecl" "', argument " "2"" of type '" "xmlAttributePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlAttributePtr >(argp2);xmlDumpAttributeDecl(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAddIDSafe(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAttrPtr arg1 = (xmlAttrPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAddIDSafe.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlAddIDSafe', argument 1 of type 'xmlAttrPtr'"); 
  }
  arg1 = (xmlAttrPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlAddIDSafe" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlAddIDSafe(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAddID(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlAttrPtr arg4 = (xmlAttrPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  void *arg40 ;
  xmlIDPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAddID.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAddID" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlAddID', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlAddID" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }res4 = SWIG_ConvertPtr(args[3], &arg40, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method 'xmlAddID', argument 4 of type 'xmlAttrPtr'"); 
  }
  arg4 = (xmlAttrPtr) arg40;result = (xmlIDPtr)xmlAddID(arg1,arg2,(unsigned char const *)arg3,arg4);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlID, 0 |  0 );
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeIDTable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlIDTablePtr arg1 = (xmlIDTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeIDTable.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeIDTable" "', argument " "1"" of type '" "xmlIDTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlIDTablePtr >(argp1);xmlFreeIDTable(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetID(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlAttrPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetID.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetID', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlGetID" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlAttrPtr)xmlGetID(arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlAttr);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlIsID(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  xmlAttrPtr arg3 = (xmlAttrPtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlIsID.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlIsID', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlIsID', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlIsID', argument 3 of type 'xmlAttrPtr'"); 
  }
  arg3 = (xmlAttrPtr) arg30;result = (int)xmlIsID(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRemoveID(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlAttrPtr arg2 = (xmlAttrPtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRemoveID.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlRemoveID', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlRemoveID', argument 2 of type 'xmlAttrPtr'"); 
  }
  arg2 = (xmlAttrPtr) arg20;result = (int)xmlRemoveID(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAddRef(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlAttrPtr arg4 = (xmlAttrPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  void *arg40 ;
  xmlRefPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAddRef.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAddRef" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlAddRef', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlAddRef" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }res4 = SWIG_ConvertPtr(args[3], &arg40, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method 'xmlAddRef', argument 4 of type 'xmlAttrPtr'"); 
  }
  arg4 = (xmlAttrPtr) arg40;result = (xmlRefPtr)xmlAddRef(arg1,arg2,(unsigned char const *)arg3,arg4);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlRef, 0 |  0 );
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeRefTable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRefTablePtr arg1 = (xmlRefTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeRefTable.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeRefTable" "', argument " "1"" of type '" "xmlRefTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRefTablePtr >(argp1);xmlFreeRefTable(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlIsRef(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  xmlAttrPtr arg3 = (xmlAttrPtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlIsRef.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlIsRef', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlIsRef', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlIsRef', argument 3 of type 'xmlAttrPtr'"); 
  }
  arg3 = (xmlAttrPtr) arg30;result = (int)xmlIsRef(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRemoveRef(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlAttrPtr arg2 = (xmlAttrPtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRemoveRef.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlRemoveRef', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlRemoveRef', argument 2 of type 'xmlAttrPtr'"); 
  }
  arg2 = (xmlAttrPtr) arg20;result = (int)xmlRemoveRef(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetRefs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlListPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetRefs.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetRefs', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlGetRefs" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlListPtr)xmlGetRefs(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlList, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewValidCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewValidCtxt.");
  
  result = (xmlValidCtxtPtr)xmlNewValidCtxt();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeValidCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeValidCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeValidCtxt" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);xmlFreeValidCtxt(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateRoot(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateRoot.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateRoot" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidateRoot', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;result = (int)xmlValidateRoot(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateElementDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlElementPtr arg3 = (xmlElementPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateElementDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateElementDecl" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidateElementDecl', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlValidateElementDecl', argument 3 of type 'xmlElementPtr'"); 
  }
  arg3 = (xmlElementPtr) arg30;result = (int)xmlValidateElementDecl(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidNormalizeAttributeValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidNormalizeAttributeValue.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlValidNormalizeAttributeValue', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidNormalizeAttributeValue', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlValidNormalizeAttributeValue" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlValidNormalizeAttributeValue" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (xmlChar *)xmlValidNormalizeAttributeValue(arg1,arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidCtxtNormalizeAttributeValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidCtxtNormalizeAttributeValue.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidCtxtNormalizeAttributeValue" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidCtxtNormalizeAttributeValue', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlValidCtxtNormalizeAttributeValue', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlValidCtxtNormalizeAttributeValue" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlValidCtxtNormalizeAttributeValue" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }result = (xmlChar *)xmlValidCtxtNormalizeAttributeValue(arg1,arg2,arg3,(unsigned char const *)arg4,(unsigned char const *)arg5);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateAttributeDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlAttributePtr arg3 = (xmlAttributePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateAttributeDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateAttributeDecl" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidateAttributeDecl', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlAttribute, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlValidateAttributeDecl" "', argument " "3"" of type '" "xmlAttributePtr""'"); 
  }
  arg3 = reinterpret_cast< xmlAttributePtr >(argp3);result = (int)xmlValidateAttributeDecl(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateAttributeValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlAttributeType arg1 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateAttributeValue.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlValidateAttributeValue" "', argument " "1"" of type '" "xmlAttributeType""'");
  } 
  arg1 = static_cast< xmlAttributeType >(val1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlValidateAttributeValue" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlValidateAttributeValue(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateNotationDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNotationPtr arg3 = (xmlNotationPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateNotationDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateNotationDecl" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidateNotationDecl', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlNotation, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlValidateNotationDecl" "', argument " "3"" of type '" "xmlNotationPtr""'"); 
  }
  arg3 = reinterpret_cast< xmlNotationPtr >(argp3);result = (int)xmlValidateNotationDecl(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateDtd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlDtdPtr arg3 = (xmlDtdPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateDtd.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateDtd" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidateDtd', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlValidateDtd', argument 3 of type 'xmlDtdPtr'"); 
  }
  arg3 = (xmlDtdPtr) arg30;result = (int)xmlValidateDtd(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateDtdFinal(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateDtdFinal.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateDtdFinal" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidateDtdFinal', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;result = (int)xmlValidateDtdFinal(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateDocument(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateDocument.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateDocument" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidateDocument', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;result = (int)xmlValidateDocument(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateElement" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidateElement', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlValidateElement', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);result = (int)xmlValidateElement(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateOneElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateOneElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateOneElement" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidateOneElement', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlValidateOneElement', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);result = (int)xmlValidateOneElement(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateOneAttribute(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  xmlAttrPtr arg4 = (xmlAttrPtr) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int res4 ;
  void *arg40 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateOneAttribute.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateOneAttribute" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidateOneAttribute', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlValidateOneAttribute', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);res4 = SWIG_ConvertPtr(args[3], &arg40, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method 'xmlValidateOneAttribute', argument 4 of type 'xmlAttrPtr'"); 
  }
  arg4 = (xmlAttrPtr) arg40;if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlValidateOneAttribute" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }result = (int)xmlValidateOneAttribute(arg1,arg2,arg3,arg4,(unsigned char const *)arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateOneNamespace(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlNsPtr arg5 = (xmlNsPtr) 0 ;
  xmlChar *arg6 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  void *arg50 ;
  int res6 ;
  char *buf6 = 0 ;
  size_t size6 = 0 ;
  int alloc6 = 0 ;
  int result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateOneNamespace.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateOneNamespace" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidateOneNamespace', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlValidateOneNamespace', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlValidateOneNamespace" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }res5 = SWIG_ConvertPtr(args[4], &arg50, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method 'xmlValidateOneNamespace', argument 5 of type 'xmlNsPtr'"); 
  }
  arg5 = (xmlNsPtr) arg50;if (args[5]->IsNull()) {
    arg6 = NULL;
  } else {
    res6 = SWIG_AsCharPtrAndSize(args[5], &buf6, &size6, &alloc6);
    
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlValidateOneNamespace" "', argument " "6"" of type '" "xmlChar const *""'");
    }
    
    arg6 = reinterpret_cast< xmlChar * >(buf6);
  }result = (int)xmlValidateOneNamespace(arg1,arg2,arg3,(unsigned char const *)arg4,arg5,(unsigned char const *)arg6);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateDocumentFinal(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateDocumentFinal.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateDocumentFinal" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidateDocumentFinal', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;result = (int)xmlValidateDocumentFinal(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateNotationUse(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateNotationUse.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateNotationUse" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidateNotationUse', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlValidateNotationUse" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (int)xmlValidateNotationUse(arg1,arg2,(unsigned char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlIsMixedElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlIsMixedElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlIsMixedElement', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlIsMixedElement" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlIsMixedElement(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetDtdAttrDesc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDtdPtr arg1 = (xmlDtdPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlAttributePtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetDtdAttrDesc.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetDtdAttrDesc', argument 1 of type 'xmlDtdPtr'"); 
  }
  arg1 = (xmlDtdPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlGetDtdAttrDesc" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlGetDtdAttrDesc" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlAttributePtr)xmlGetDtdAttrDesc(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAttribute, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetDtdQAttrDesc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDtdPtr arg1 = (xmlDtdPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  xmlAttributePtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetDtdQAttrDesc.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetDtdQAttrDesc', argument 1 of type 'xmlDtdPtr'"); 
  }
  arg1 = (xmlDtdPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlGetDtdQAttrDesc" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlGetDtdQAttrDesc" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlGetDtdQAttrDesc" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (xmlAttributePtr)xmlGetDtdQAttrDesc(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAttribute, 0 |  0 );
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetDtdNotationDesc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDtdPtr arg1 = (xmlDtdPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlNotationPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetDtdNotationDesc.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetDtdNotationDesc', argument 1 of type 'xmlDtdPtr'"); 
  }
  arg1 = (xmlDtdPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlGetDtdNotationDesc" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlNotationPtr)xmlGetDtdNotationDesc(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlNotation, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetDtdQElementDesc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDtdPtr arg1 = (xmlDtdPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlElementPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetDtdQElementDesc.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetDtdQElementDesc', argument 1 of type 'xmlDtdPtr'"); 
  }
  arg1 = (xmlDtdPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlGetDtdQElementDesc" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlGetDtdQElementDesc" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlElementPtr)xmlGetDtdQElementDesc(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlElement);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetDtdElementDesc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDtdPtr arg1 = (xmlDtdPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlElementPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetDtdElementDesc.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetDtdElementDesc', argument 1 of type 'xmlDtdPtr'"); 
  }
  arg1 = (xmlDtdPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlGetDtdElementDesc" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlElementPtr)xmlGetDtdElementDesc(arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlElement);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidGetPotentialChildren(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlElementContent *arg1 = (xmlElementContent *) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  int *arg3 = (int *) 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 result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidGetPotentialChildren.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidGetPotentialChildren" "', argument " "1"" of type '" "xmlElementContent *""'"); 
  }
  arg1 = reinterpret_cast< xmlElementContent * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlValidGetPotentialChildren" "', argument " "2"" of type '" "xmlChar const **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlValidGetPotentialChildren" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlValidGetPotentialChildren" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (int)xmlValidGetPotentialChildren(arg1,(unsigned char const **)arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidGetValidElements(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNode *arg1 = (xmlNode *) 0 ;
  xmlNode *arg2 = (xmlNode *) 0 ;
  xmlChar **arg3 = (xmlChar **) 0 ;
  int arg4 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidGetValidElements.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlValidGetValidElements', argument 1 of type 'xmlNode *'"); 
    }
  }
  
  arg1 = ((xmlNode *) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidGetValidElements', argument 2 of type 'xmlNode *'"); 
    }
  }
  
  arg2 = ((xmlNode *) arg20);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlValidGetValidElements" "', argument " "3"" of type '" "xmlChar const **""'"); 
  }
  arg3 = reinterpret_cast< xmlChar ** >(argp3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlValidGetValidElements" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (int)xmlValidGetValidElements(arg1,arg2,(unsigned char const **)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateNameValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateNameValue.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateNameValue" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (int)xmlValidateNameValue((unsigned char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateNamesValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateNamesValue.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateNamesValue" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (int)xmlValidateNamesValue((unsigned char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateNmtokenValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateNmtokenValue.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateNmtokenValue" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (int)xmlValidateNmtokenValue((unsigned char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidateNmtokensValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidateNmtokensValue.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidateNmtokensValue" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (int)xmlValidateNmtokensValue((unsigned char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidBuildContentModel(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlElementPtr arg2 = (xmlElementPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidBuildContentModel.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidBuildContentModel" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidBuildContentModel', argument 2 of type 'xmlElementPtr'"); 
  }
  arg2 = (xmlElementPtr) arg20;result = (int)xmlValidBuildContentModel(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidatePushElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidatePushElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidatePushElement" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidatePushElement', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlValidatePushElement', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlValidatePushElement" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (int)xmlValidatePushElement(arg1,arg2,arg3,(unsigned char const *)arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidatePushCData(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidatePushCData.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidatePushCData" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlValidatePushCData" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlValidatePushCData" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlValidatePushCData(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlValidatePopElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlValidCtxtPtr arg1 = (xmlValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlValidatePopElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlValidatePopElement" "', argument " "1"" of type '" "xmlValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlValidatePopElement', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlValidatePopElement', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlValidatePopElement" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (int)xmlValidatePopElement(arg1,arg2,arg3,(unsigned char const *)arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_INTERNAL_GENERAL_ENTITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_INTERNAL_GENERAL_ENTITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_EXTERNAL_GENERAL_PARSED_ENTITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_EXTERNAL_GENERAL_PARSED_ENTITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_EXTERNAL_GENERAL_UNPARSED_ENTITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_EXTERNAL_GENERAL_UNPARSED_ENTITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_INTERNAL_PARAMETER_ENTITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_INTERNAL_PARAMETER_ENTITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_EXTERNAL_PARAMETER_ENTITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_EXTERNAL_PARAMETER_ENTITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_INTERNAL_PREDEFINED_ENTITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_INTERNAL_PREDEFINED_ENTITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_flags_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_flags_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlEntity_flags_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->flags = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_flags_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_flags_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (int) ((arg1)->flags);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_expandedSize_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  unsigned long arg2 ;
  int res1 ;
  void *arg10 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_expandedSize_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;ecode2 = SWIG_AsVal_unsigned_SS_long(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlEntity_expandedSize_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);if (arg1) (arg1)->expandedSize = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_expandedSize_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  unsigned long result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_expandedSize_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (unsigned long) ((arg1)->expandedSize);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity__private_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity__private_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlEntity__private_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);_xmlEntity__private_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity__private_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity__private_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (int)_xmlEntity__private_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  xmlElementType arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_type_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlEntity_type_set" "', argument " "2"" of type '" "xmlElementType""'");
  } 
  arg2 = static_cast< xmlElementType >(val2);_xmlEntity_type_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlElementType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_type_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (xmlElementType)_xmlEntity_type_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_name_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlEntity_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlEntity_name_set(arg1,(unsigned char const *)arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_name_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (xmlChar *)_xmlEntity_name_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_children_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_children_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlEntity_children_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlEntity_children_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_children_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_children_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (_xmlNode *)_xmlEntity_children_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_last_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_last_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlEntity_last_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlEntity_last_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_last_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_last_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (_xmlNode *)_xmlEntity_last_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_parent_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  _xmlDtd *arg2 = (_xmlDtd *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_parent_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlEntity_parent_set', argument 2 of type '_xmlDtd *'"); 
  }
  arg2 = (_xmlDtd *) arg20;_xmlEntity_parent_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_parent_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlDtd *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_parent_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (_xmlDtd *)_xmlEntity_parent_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDtd);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_next_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlEntity_next_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlEntity_next_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_next_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (_xmlNode *)_xmlEntity_next_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_prev_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_prev_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlEntity_prev_set', argument 2 of type '_xmlNode *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);_xmlEntity_prev_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_prev_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_prev_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (_xmlNode *)_xmlEntity_prev_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_doc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  _xmlDoc *arg2 = (_xmlDoc *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_doc_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlEntity_doc_set', argument 2 of type '_xmlDoc *'"); 
  }
  arg2 = (_xmlDoc *) arg20;_xmlEntity_doc_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_doc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlDoc *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_doc_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (_xmlDoc *)_xmlEntity_doc_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_orig_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_orig_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlEntity_orig_set" "', argument " "2"" of type '" "xmlChar *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlEntity_orig_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_orig_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_orig_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (xmlChar *)_xmlEntity_orig_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_content_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_content_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlEntity_content_set" "', argument " "2"" of type '" "xmlChar *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlEntity_content_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_content_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_content_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (xmlChar *)_xmlEntity_content_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_length_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_length_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlEntity_length_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);_xmlEntity_length_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_length_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_length_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (int)_xmlEntity_length_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_etype_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  xmlEntityType arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_etype_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlEntity_etype_set" "', argument " "2"" of type '" "xmlEntityType""'");
  } 
  arg2 = static_cast< xmlEntityType >(val2);_xmlEntity_etype_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_etype_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlEntityType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_etype_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (xmlEntityType)_xmlEntity_etype_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_ExternalID_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_ExternalID_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlEntity_ExternalID_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlEntity_ExternalID_set(arg1,(unsigned char const *)arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_ExternalID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_ExternalID_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (xmlChar *)_xmlEntity_ExternalID_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_SystemID_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_SystemID_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlEntity_SystemID_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlEntity_SystemID_set(arg1,(unsigned char const *)arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_SystemID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_SystemID_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (xmlChar *)_xmlEntity_SystemID_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_nexte_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  _xmlEntity *arg2 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_nexte_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlEntity_nexte_set', argument 2 of type '_xmlEntity *'"); 
  }
  arg2 = (_xmlEntity *) arg20;_xmlEntity_nexte_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_nexte_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  _xmlEntity *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_nexte_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (_xmlEntity *)_xmlEntity_nexte_get(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlEntity);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_URI_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_URI_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlEntity_URI_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }_xmlEntity_URI_set(arg1,(unsigned char const *)arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_URI_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_URI_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (xmlChar *)_xmlEntity_URI_get(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_owner_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_owner_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlEntity_owner_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);_xmlEntity_owner_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_owner_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_owner_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (int)_xmlEntity_owner_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlEntity_checked_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_checked_set', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlEntity_checked_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);_xmlEntity_checked_set(arg1,arg2);
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlEntity_checked_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlEntity *arg1 = (_xmlEntity *) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '_xmlEntity_checked_get', argument 1 of type '_xmlEntity *'"); 
  }
  arg1 = (_xmlEntity *) arg10;result = (int)_xmlEntity_checked_get(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}

SWIGINTERN void delete__xmlEntity(_xmlEntity *self){
        destroyWrap((xmlNode*)self);
    }

static void _wrap_delete__xmlEntity(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlEntity * arg1 = (_xmlEntity *)proxy->swigCObject;
    delete__xmlEntity(arg1);
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap_new__xmlEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlEntity *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlEntity.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlEntity.");
  result = (_xmlEntity *)new _xmlEntity();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlEntity, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  xmlChar *arg6 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  size_t size6 = 0 ;
  int alloc6 = 0 ;
  xmlEntityPtr result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewEntity', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewEntity" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlNewEntity" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlNewEntity" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlNewEntity" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }if (args[5]->IsNull()) {
    arg6 = NULL;
  } else {
    res6 = SWIG_AsCharPtrAndSize(args[5], &buf6, &size6, &alloc6);
    
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlNewEntity" "', argument " "6"" of type '" "xmlChar const *""'");
    }
    
    arg6 = reinterpret_cast< xmlChar * >(buf6);
  }result = (xmlEntityPtr)xmlNewEntity(arg1,(unsigned char const *)arg2,arg3,(unsigned char const *)arg4,(unsigned char const *)arg5,(unsigned char const *)arg6);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlEntity);
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlEntityPtr arg1 = (xmlEntityPtr) 0 ;
  int res1 ;
  void *arg10 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlFreeEntity', argument 1 of type 'xmlEntityPtr'"); 
  }
  arg1 = (xmlEntityPtr) arg10;xmlFreeEntity(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAddEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  int arg2 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int arg4 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  xmlChar *arg6 = (xmlChar *) 0 ;
  xmlChar *arg7 = (xmlChar *) 0 ;
  xmlEntityPtr *arg8 = (xmlEntityPtr *) 0 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  size_t size6 = 0 ;
  int alloc6 = 0 ;
  int res7 ;
  char *buf7 = 0 ;
  size_t size7 = 0 ;
  int alloc7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int result;
  
  if (args.Length() < 8 || args.Length() > 8) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAddEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlAddEntity', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlAddEntity" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlAddEntity" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlAddEntity" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlAddEntity" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }if (args[5]->IsNull()) {
    arg6 = NULL;
  } else {
    res6 = SWIG_AsCharPtrAndSize(args[5], &buf6, &size6, &alloc6);
    
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlAddEntity" "', argument " "6"" of type '" "xmlChar const *""'");
    }
    
    arg6 = reinterpret_cast< xmlChar * >(buf6);
  }if (args[6]->IsNull()) {
    arg7 = NULL;
  } else {
    res7 = SWIG_AsCharPtrAndSize(args[6], &buf7, &size7, &alloc7);
    
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "xmlAddEntity" "', argument " "7"" of type '" "xmlChar const *""'");
    }
    
    arg7 = reinterpret_cast< xmlChar * >(buf7);
  }res8 = SWIG_ConvertPtr(args[7], &argp8,SWIGTYPE_p_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "xmlAddEntity" "', argument " "8"" of type '" "xmlEntityPtr *""'"); 
  }
  arg8 = reinterpret_cast< xmlEntityPtr * >(argp8);result = (int)xmlAddEntity(arg1,arg2,(unsigned char const *)arg3,arg4,(unsigned char const *)arg5,(unsigned char const *)arg6,(unsigned char const *)arg7,arg8);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAddDocEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  xmlChar *arg6 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  size_t size6 = 0 ;
  int alloc6 = 0 ;
  xmlEntityPtr result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAddDocEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlAddDocEntity', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlAddDocEntity" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlAddDocEntity" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlAddDocEntity" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlAddDocEntity" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }if (args[5]->IsNull()) {
    arg6 = NULL;
  } else {
    res6 = SWIG_AsCharPtrAndSize(args[5], &buf6, &size6, &alloc6);
    
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlAddDocEntity" "', argument " "6"" of type '" "xmlChar const *""'");
    }
    
    arg6 = reinterpret_cast< xmlChar * >(buf6);
  }result = (xmlEntityPtr)xmlAddDocEntity(arg1,(unsigned char const *)arg2,arg3,(unsigned char const *)arg4,(unsigned char const *)arg5,(unsigned char const *)arg6);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlEntity);
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAddDtdEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  xmlChar *arg6 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  size_t size6 = 0 ;
  int alloc6 = 0 ;
  xmlEntityPtr result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAddDtdEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlAddDtdEntity', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlAddDtdEntity" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlAddDtdEntity" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlAddDtdEntity" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlAddDtdEntity" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }if (args[5]->IsNull()) {
    arg6 = NULL;
  } else {
    res6 = SWIG_AsCharPtrAndSize(args[5], &buf6, &size6, &alloc6);
    
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlAddDtdEntity" "', argument " "6"" of type '" "xmlChar const *""'");
    }
    
    arg6 = reinterpret_cast< xmlChar * >(buf6);
  }result = (xmlEntityPtr)xmlAddDtdEntity(arg1,(unsigned char const *)arg2,arg3,(unsigned char const *)arg4,(unsigned char const *)arg5,(unsigned char const *)arg6);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlEntity);
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetPredefinedEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlEntityPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetPredefinedEntity.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlGetPredefinedEntity" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlEntityPtr)xmlGetPredefinedEntity((unsigned char const *)arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlEntity);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetDocEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDoc *arg1 = (xmlDoc *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlEntityPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetDocEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetDocEntity', argument 1 of type 'xmlDoc const *'"); 
  }
  arg1 = (xmlDoc *) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlGetDocEntity" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlEntityPtr)xmlGetDocEntity((_xmlDoc const *)arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlEntity);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetDtdEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlEntityPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetDtdEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetDtdEntity', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlGetDtdEntity" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlEntityPtr)xmlGetDtdEntity(arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlEntity);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetParameterEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlEntityPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetParameterEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlGetParameterEntity', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlGetParameterEntity" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlEntityPtr)xmlGetParameterEntity(arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlEntity);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlEncodeEntitiesReentrant(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlEncodeEntitiesReentrant.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlEncodeEntitiesReentrant', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlEncodeEntitiesReentrant" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlEncodeEntitiesReentrant(arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlEncodeSpecialChars(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDoc *arg1 = (xmlDoc *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlEncodeSpecialChars.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlEncodeSpecialChars', argument 1 of type 'xmlDoc const *'"); 
  }
  arg1 = (xmlDoc *) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlEncodeSpecialChars" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlEncodeSpecialChars((_xmlDoc const *)arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCreateEntitiesTable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlEntitiesTablePtr result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCreateEntitiesTable.");
  
  result = (xmlEntitiesTablePtr)xmlCreateEntitiesTable();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyEntitiesTable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlEntitiesTablePtr arg1 = (xmlEntitiesTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlEntitiesTablePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyEntitiesTable.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCopyEntitiesTable" "', argument " "1"" of type '" "xmlEntitiesTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlEntitiesTablePtr >(argp1);result = (xmlEntitiesTablePtr)xmlCopyEntitiesTable(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeEntitiesTable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlEntitiesTablePtr arg1 = (xmlEntitiesTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeEntitiesTable.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeEntitiesTable" "', argument " "1"" of type '" "xmlEntitiesTablePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlEntitiesTablePtr >(argp1);xmlFreeEntitiesTable(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDumpEntitiesTable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlEntitiesTablePtr arg2 = (xmlEntitiesTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDumpEntitiesTable.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDumpEntitiesTable" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlHashTable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlDumpEntitiesTable" "', argument " "2"" of type '" "xmlEntitiesTablePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlEntitiesTablePtr >(argp2);xmlDumpEntitiesTable(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDumpEntityDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlEntityPtr arg2 = (xmlEntityPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDumpEntityDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDumpEntityDecl" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlDumpEntityDecl', argument 2 of type 'xmlEntityPtr'"); 
  }
  arg2 = (xmlEntityPtr) arg20;xmlDumpEntityDecl(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_ENC_ERR_SUCCESS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ENC_ERR_SUCCESS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ENC_ERR_SPACE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ENC_ERR_SPACE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ENC_ERR_INPUT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ENC_ERR_INPUT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ENC_ERR_PARTIAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ENC_ERR_PARTIAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ENC_ERR_INTERNAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ENC_ERR_INTERNAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_ENC_ERR_MEMORY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_ENC_ERR_MEMORY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_NONE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_NONE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_UTF8_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_UTF8));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_UTF16LE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_UTF16LE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_UTF16BE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_UTF16BE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_UCS4LE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_UCS4LE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_UCS4BE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_UCS4BE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_EBCDIC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_EBCDIC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_UCS4_2143_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_UCS4_2143));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_UCS4_3412_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_UCS4_3412));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_UCS2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_UCS2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_8859_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_8859_1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_8859_2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_8859_2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_8859_3_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_8859_3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_8859_4_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_8859_4));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_8859_5_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_8859_5));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_8859_6_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_8859_6));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_8859_7_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_8859_7));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_8859_8_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_8859_8));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_8859_9_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_8859_9));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_2022_JP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_2022_JP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_SHIFT_JIS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_SHIFT_JIS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_EUC_JP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_EUC_JP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CHAR_ENCODING_ASCII_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CHAR_ENCODING_ASCII));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlCharEncodingHandler_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlCharEncodingHandler *arg1 = (_xmlCharEncodingHandler *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlCharEncodingHandler_name_set" "', argument " "1"" of type '" "_xmlCharEncodingHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlCharEncodingHandler * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlCharEncodingHandler_name_set" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }delete[] arg1->name;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->name = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->name = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlCharEncodingHandler_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlCharEncodingHandler *arg1 = (_xmlCharEncodingHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlCharEncodingHandler_name_get" "', argument " "1"" of type '" "_xmlCharEncodingHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlCharEncodingHandler * >(argp1);result = (char *) ((arg1)->name);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlCharEncodingHandler_input_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlCharEncodingHandler *arg1 = (_xmlCharEncodingHandler *) 0 ;
  xmlCharEncodingInputFunc arg2 = (xmlCharEncodingInputFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlCharEncodingHandler_input_set" "', argument " "1"" of type '" "_xmlCharEncodingHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlCharEncodingHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_unsigned_char_p_int_p_q_const__unsigned_char_p_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlCharEncodingHandler_input_set" "', argument " "2"" of type '" "xmlCharEncodingInputFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->input = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlCharEncodingHandler_input_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlCharEncodingHandler *arg1 = (_xmlCharEncodingHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlCharEncodingInputFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlCharEncodingHandler_input_get" "', argument " "1"" of type '" "_xmlCharEncodingHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlCharEncodingHandler * >(argp1);result = (xmlCharEncodingInputFunc) ((arg1)->input);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_unsigned_char_p_int_p_q_const__unsigned_char_p_int__int);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlCharEncodingHandler_output_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlCharEncodingHandler *arg1 = (_xmlCharEncodingHandler *) 0 ;
  xmlCharEncodingOutputFunc arg2 = (xmlCharEncodingOutputFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlCharEncodingHandler_output_set" "', argument " "1"" of type '" "_xmlCharEncodingHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlCharEncodingHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_unsigned_char_p_int_p_q_const__unsigned_char_p_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlCharEncodingHandler_output_set" "', argument " "2"" of type '" "xmlCharEncodingOutputFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->output = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlCharEncodingHandler_output_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlCharEncodingHandler *arg1 = (_xmlCharEncodingHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlCharEncodingOutputFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlCharEncodingHandler_output_get" "', argument " "1"" of type '" "_xmlCharEncodingHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlCharEncodingHandler * >(argp1);result = (xmlCharEncodingOutputFunc) ((arg1)->output);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_unsigned_char_p_int_p_q_const__unsigned_char_p_int__int);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlCharEncodingHandler_iconv_in_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlCharEncodingHandler *arg1 = (_xmlCharEncodingHandler *) 0 ;
  iconv_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlCharEncodingHandler_iconv_in_set" "', argument " "1"" of type '" "_xmlCharEncodingHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlCharEncodingHandler * >(argp1);{
    {
      res2 = SWIG_ConvertPtr(value, &argp2, SWIGTYPE_p_iconv_t,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlCharEncodingHandler_iconv_in_set" "', argument " "2"" of type '" "iconv_t""'"); 
      }  
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_xmlCharEncodingHandler_iconv_in_set" "', argument " "2"" of type '" "iconv_t""'");
      } else {
        arg2 = *(reinterpret_cast< iconv_t * >(argp2));
      }
    }
  }
  if (arg1) (arg1)->iconv_in = arg2;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlCharEncodingHandler_iconv_in_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlCharEncodingHandler *arg1 = (_xmlCharEncodingHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  iconv_t result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlCharEncodingHandler_iconv_in_get" "', argument " "1"" of type '" "_xmlCharEncodingHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlCharEncodingHandler * >(argp1);result =  ((arg1)->iconv_in);
  jsresult = SWIG_NewPointerObj((new iconv_t(result)), SWIGTYPE_p_iconv_t, SWIG_POINTER_OWN |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlCharEncodingHandler_iconv_out_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlCharEncodingHandler *arg1 = (_xmlCharEncodingHandler *) 0 ;
  iconv_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlCharEncodingHandler_iconv_out_set" "', argument " "1"" of type '" "_xmlCharEncodingHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlCharEncodingHandler * >(argp1);{
    {
      res2 = SWIG_ConvertPtr(value, &argp2, SWIGTYPE_p_iconv_t,  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlCharEncodingHandler_iconv_out_set" "', argument " "2"" of type '" "iconv_t""'"); 
      }  
      if (!argp2) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "_xmlCharEncodingHandler_iconv_out_set" "', argument " "2"" of type '" "iconv_t""'");
      } else {
        arg2 = *(reinterpret_cast< iconv_t * >(argp2));
      }
    }
  }
  if (arg1) (arg1)->iconv_out = arg2;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlCharEncodingHandler_iconv_out_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlCharEncodingHandler *arg1 = (_xmlCharEncodingHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  iconv_t result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlCharEncodingHandler_iconv_out_get" "', argument " "1"" of type '" "_xmlCharEncodingHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlCharEncodingHandler * >(argp1);result =  ((arg1)->iconv_out);
  jsresult = SWIG_NewPointerObj((new iconv_t(result)), SWIGTYPE_p_iconv_t, SWIG_POINTER_OWN |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlCharEncodingHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlCharEncodingHandler *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlCharEncodingHandler.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlCharEncodingHandler.");
  result = (_xmlCharEncodingHandler *)new _xmlCharEncodingHandler();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlCharEncodingHandler, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlCharEncodingHandler(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlCharEncodingHandler * arg1 = (_xmlCharEncodingHandler *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap_xmlInitCharEncodingHandlers(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlInitCharEncodingHandlers.");
  
  xmlInitCharEncodingHandlers();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCleanupCharEncodingHandlers(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCleanupCharEncodingHandlers.");
  
  xmlCleanupCharEncodingHandlers();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRegisterCharEncodingHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCharEncodingHandlerPtr arg1 = (xmlCharEncodingHandlerPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRegisterCharEncodingHandler.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRegisterCharEncodingHandler" "', argument " "1"" of type '" "xmlCharEncodingHandlerPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlCharEncodingHandlerPtr >(argp1);xmlRegisterCharEncodingHandler(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlLookupCharEncodingHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCharEncoding arg1 ;
  xmlCharEncodingHandlerPtr *arg2 = (xmlCharEncodingHandlerPtr *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlLookupCharEncodingHandler.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlLookupCharEncodingHandler" "', argument " "1"" of type '" "xmlCharEncoding""'");
  } 
  arg1 = static_cast< xmlCharEncoding >(val1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlLookupCharEncodingHandler" "', argument " "2"" of type '" "xmlCharEncodingHandlerPtr *""'"); 
  }
  arg2 = reinterpret_cast< xmlCharEncodingHandlerPtr * >(argp2);result = (int)xmlLookupCharEncodingHandler(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlOpenCharEncodingHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  xmlCharEncodingHandlerPtr *arg3 = (xmlCharEncodingHandlerPtr *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlOpenCharEncodingHandler.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlOpenCharEncodingHandler" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlOpenCharEncodingHandler" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlOpenCharEncodingHandler" "', argument " "3"" of type '" "xmlCharEncodingHandlerPtr *""'"); 
  }
  arg3 = reinterpret_cast< xmlCharEncodingHandlerPtr * >(argp3);result = (int)xmlOpenCharEncodingHandler((char const *)arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  // free(arg1);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetCharEncodingHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCharEncoding arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  xmlCharEncodingHandlerPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetCharEncodingHandler.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlGetCharEncodingHandler" "', argument " "1"" of type '" "xmlCharEncoding""'");
  } 
  arg1 = static_cast< xmlCharEncoding >(val1);result = (xmlCharEncodingHandlerPtr)xmlGetCharEncodingHandler(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFindCharEncodingHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlCharEncodingHandlerPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFindCharEncodingHandler.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFindCharEncodingHandler" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (xmlCharEncodingHandlerPtr)xmlFindCharEncodingHandler((char const *)arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewCharEncodingHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  xmlCharEncodingInputFunc arg2 = (xmlCharEncodingInputFunc) 0 ;
  xmlCharEncodingOutputFunc arg3 = (xmlCharEncodingOutputFunc) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlCharEncodingHandlerPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewCharEncodingHandler.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewCharEncodingHandler" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_unsigned_char_p_int_p_q_const__unsigned_char_p_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlNewCharEncodingHandler" "', argument " "2"" of type '" "xmlCharEncodingInputFunc""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[2], (void**)(&arg3), SWIGTYPE_p_f_p_unsigned_char_p_int_p_q_const__unsigned_char_p_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlNewCharEncodingHandler" "', argument " "3"" of type '" "xmlCharEncodingOutputFunc""'"); 
      }
    }
  }
  result = (xmlCharEncodingHandlerPtr)xmlNewCharEncodingHandler((char const *)arg1,arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  // free(arg1);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAddEncodingAlias(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAddEncodingAlias.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAddEncodingAlias" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlAddEncodingAlias" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (int)xmlAddEncodingAlias((char const *)arg1,(char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  // free(arg1);
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDelEncodingAlias(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDelEncodingAlias.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDelEncodingAlias" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (int)xmlDelEncodingAlias((char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetEncodingAlias(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  char *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetEncodingAlias.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlGetEncodingAlias" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (char *)xmlGetEncodingAlias((char const *)arg1);
  jsresult = SWIG_FromCharPtr((const char *)result);
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCleanupEncodingAliases(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCleanupEncodingAliases.");
  
  xmlCleanupEncodingAliases();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseCharEncoding(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlCharEncoding result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseCharEncoding.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseCharEncoding" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (xmlCharEncoding)xmlParseCharEncoding((char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetCharEncodingName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCharEncoding arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  char *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetCharEncodingName.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlGetCharEncodingName" "', argument " "1"" of type '" "xmlCharEncoding""'");
  } 
  arg1 = static_cast< xmlCharEncoding >(val1);result = (char *)xmlGetCharEncodingName(arg1);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDetectCharEncoding(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned char *arg1 = (unsigned char *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlCharEncoding result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDetectCharEncoding.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDetectCharEncoding" "', argument " "1"" of type '" "unsigned char const *""'"); 
  }
  arg1 = reinterpret_cast< unsigned char * >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlDetectCharEncoding" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlCharEncoding)xmlDetectCharEncoding((unsigned char const *)arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCharEncOutFunc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCharEncodingHandler *arg1 = (xmlCharEncodingHandler *) 0 ;
  _xmlBuffer *arg2 = (_xmlBuffer *) 0 ;
  _xmlBuffer *arg3 = (_xmlBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCharEncOutFunc.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCharEncOutFunc" "', argument " "1"" of type '" "xmlCharEncodingHandler *""'"); 
  }
  arg1 = reinterpret_cast< xmlCharEncodingHandler * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCharEncOutFunc" "', argument " "2"" of type '" "_xmlBuffer *""'"); 
  }
  arg2 = reinterpret_cast< _xmlBuffer * >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlCharEncOutFunc" "', argument " "3"" of type '" "_xmlBuffer *""'"); 
  }
  arg3 = reinterpret_cast< _xmlBuffer * >(argp3);result = (int)xmlCharEncOutFunc(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCharEncInFunc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCharEncodingHandler *arg1 = (xmlCharEncodingHandler *) 0 ;
  _xmlBuffer *arg2 = (_xmlBuffer *) 0 ;
  _xmlBuffer *arg3 = (_xmlBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCharEncInFunc.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCharEncInFunc" "', argument " "1"" of type '" "xmlCharEncodingHandler *""'"); 
  }
  arg1 = reinterpret_cast< xmlCharEncodingHandler * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCharEncInFunc" "', argument " "2"" of type '" "_xmlBuffer *""'"); 
  }
  arg2 = reinterpret_cast< _xmlBuffer * >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlCharEncInFunc" "', argument " "3"" of type '" "_xmlBuffer *""'"); 
  }
  arg3 = reinterpret_cast< _xmlBuffer * >(argp3);result = (int)xmlCharEncInFunc(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCharEncFirstLine(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCharEncodingHandler *arg1 = (xmlCharEncodingHandler *) 0 ;
  _xmlBuffer *arg2 = (_xmlBuffer *) 0 ;
  _xmlBuffer *arg3 = (_xmlBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCharEncFirstLine.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCharEncFirstLine" "', argument " "1"" of type '" "xmlCharEncodingHandler *""'"); 
  }
  arg1 = reinterpret_cast< xmlCharEncodingHandler * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCharEncFirstLine" "', argument " "2"" of type '" "_xmlBuffer *""'"); 
  }
  arg2 = reinterpret_cast< _xmlBuffer * >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlCharEncFirstLine" "', argument " "3"" of type '" "_xmlBuffer *""'"); 
  }
  arg3 = reinterpret_cast< _xmlBuffer * >(argp3);result = (int)xmlCharEncFirstLine(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCharEncCloseFunc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCharEncodingHandler *arg1 = (xmlCharEncodingHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCharEncCloseFunc.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCharEncCloseFunc" "', argument " "1"" of type '" "xmlCharEncodingHandler *""'"); 
  }
  arg1 = reinterpret_cast< xmlCharEncodingHandler * >(argp1);result = (int)xmlCharEncCloseFunc(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_UTF8Toisolat1(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned char *arg1 = (unsigned char *) 0 ;
  int *arg2 = (int *) 0 ;
  unsigned char *arg3 = (unsigned char *) 0 ;
  int *arg4 = (int *) 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 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_UTF8Toisolat1.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UTF8Toisolat1" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = reinterpret_cast< unsigned char * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UTF8Toisolat1" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UTF8Toisolat1" "', argument " "3"" of type '" "unsigned char const *""'"); 
  }
  arg3 = reinterpret_cast< unsigned char * >(argp3);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "UTF8Toisolat1" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);result = (int)UTF8Toisolat1(arg1,arg2,(unsigned char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_isolat1ToUTF8(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned char *arg1 = (unsigned char *) 0 ;
  int *arg2 = (int *) 0 ;
  unsigned char *arg3 = (unsigned char *) 0 ;
  int *arg4 = (int *) 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 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_isolat1ToUTF8.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isolat1ToUTF8" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = reinterpret_cast< unsigned char * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "isolat1ToUTF8" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "isolat1ToUTF8" "', argument " "3"" of type '" "unsigned char const *""'"); 
  }
  arg3 = reinterpret_cast< unsigned char * >(argp3);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "isolat1ToUTF8" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);result = (int)isolat1ToUTF8(arg1,arg2,(unsigned char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap__xmlParserInputBuffer_context_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_context_set" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->context = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInputBuffer_context_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_context_get" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);result = (void *) ((arg1)->context);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInputBuffer_readcallback_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  xmlInputReadCallback arg2 = (xmlInputReadCallback) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_readcallback_set" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_char_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlParserInputBuffer_readcallback_set" "', argument " "2"" of type '" "xmlInputReadCallback""'"); 
      }
    }
  }
  if (arg1) (arg1)->readcallback = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInputBuffer_readcallback_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlInputReadCallback result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_readcallback_get" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);result = (xmlInputReadCallback) ((arg1)->readcallback);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_char_int__int);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInputBuffer_closecallback_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  xmlInputCloseCallback arg2 = (xmlInputCloseCallback) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_closecallback_set" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlParserInputBuffer_closecallback_set" "', argument " "2"" of type '" "xmlInputCloseCallback""'"); 
      }
    }
  }
  if (arg1) (arg1)->closecallback = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInputBuffer_closecallback_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlInputCloseCallback result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_closecallback_get" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);result = (xmlInputCloseCallback) ((arg1)->closecallback);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__int);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInputBuffer_encoder_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  xmlCharEncodingHandlerPtr arg2 = (xmlCharEncodingHandlerPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_encoder_set" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlCharEncodingHandler, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserInputBuffer_encoder_set" "', argument " "2"" of type '" "xmlCharEncodingHandlerPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlCharEncodingHandlerPtr >(argp2);if (arg1) (arg1)->encoder = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInputBuffer_encoder_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlCharEncodingHandlerPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_encoder_get" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);result = (xmlCharEncodingHandlerPtr) ((arg1)->encoder);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInputBuffer_buffer_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  xmlBufPtr arg2 = (xmlBufPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_buffer_set" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlBuf, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserInputBuffer_buffer_set" "', argument " "2"" of type '" "xmlBufPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlBufPtr >(argp2);if (arg1) (arg1)->buffer = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInputBuffer_buffer_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlBufPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_buffer_get" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);result = (xmlBufPtr) ((arg1)->buffer);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlBuf, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInputBuffer_raw_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  xmlBufPtr arg2 = (xmlBufPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_raw_set" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlBuf, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserInputBuffer_raw_set" "', argument " "2"" of type '" "xmlBufPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlBufPtr >(argp2);if (arg1) (arg1)->raw = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInputBuffer_raw_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlBufPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_raw_get" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);result = (xmlBufPtr) ((arg1)->raw);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlBuf, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInputBuffer_compressed_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_compressed_set" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserInputBuffer_compressed_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->compressed = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInputBuffer_compressed_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_compressed_get" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);result = (int) ((arg1)->compressed);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInputBuffer_error_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_error_set" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserInputBuffer_error_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->error = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInputBuffer_error_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_error_get" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);result = (int) ((arg1)->error);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInputBuffer_rawconsumed_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_rawconsumed_set" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_long(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserInputBuffer_rawconsumed_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);if (arg1) (arg1)->rawconsumed = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInputBuffer_rawconsumed_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInputBuffer *arg1 = (_xmlParserInputBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInputBuffer_rawconsumed_get" "', argument " "1"" of type '" "_xmlParserInputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInputBuffer * >(argp1);result = (unsigned long) ((arg1)->rawconsumed);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlParserInputBuffer(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlParserInputBuffer *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlParserInputBuffer.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlParserInputBuffer.");
  result = (_xmlParserInputBuffer *)new _xmlParserInputBuffer();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlParserInputBuffer, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlParserInputBuffer(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlParserInputBuffer * arg1 = (_xmlParserInputBuffer *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlOutputBuffer_context_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlOutputBuffer *arg1 = (_xmlOutputBuffer *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlOutputBuffer_context_set" "', argument " "1"" of type '" "_xmlOutputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlOutputBuffer * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->context = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlOutputBuffer_context_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlOutputBuffer *arg1 = (_xmlOutputBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlOutputBuffer_context_get" "', argument " "1"" of type '" "_xmlOutputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlOutputBuffer * >(argp1);result = (void *) ((arg1)->context);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlOutputBuffer_writecallback_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlOutputBuffer *arg1 = (_xmlOutputBuffer *) 0 ;
  xmlOutputWriteCallback arg2 = (xmlOutputWriteCallback) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlOutputBuffer_writecallback_set" "', argument " "1"" of type '" "_xmlOutputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlOutputBuffer * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlOutputBuffer_writecallback_set" "', argument " "2"" of type '" "xmlOutputWriteCallback""'"); 
      }
    }
  }
  if (arg1) (arg1)->writecallback = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlOutputBuffer_writecallback_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlOutputBuffer *arg1 = (_xmlOutputBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlOutputWriteCallback result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlOutputBuffer_writecallback_get" "', argument " "1"" of type '" "_xmlOutputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlOutputBuffer * >(argp1);result = (xmlOutputWriteCallback) ((arg1)->writecallback);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char_int__int);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlOutputBuffer_closecallback_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlOutputBuffer *arg1 = (_xmlOutputBuffer *) 0 ;
  xmlOutputCloseCallback arg2 = (xmlOutputCloseCallback) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlOutputBuffer_closecallback_set" "', argument " "1"" of type '" "_xmlOutputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlOutputBuffer * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlOutputBuffer_closecallback_set" "', argument " "2"" of type '" "xmlOutputCloseCallback""'"); 
      }
    }
  }
  if (arg1) (arg1)->closecallback = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlOutputBuffer_closecallback_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlOutputBuffer *arg1 = (_xmlOutputBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlOutputCloseCallback result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlOutputBuffer_closecallback_get" "', argument " "1"" of type '" "_xmlOutputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlOutputBuffer * >(argp1);result = (xmlOutputCloseCallback) ((arg1)->closecallback);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__int);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlOutputBuffer_encoder_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlOutputBuffer *arg1 = (_xmlOutputBuffer *) 0 ;
  xmlCharEncodingHandlerPtr arg2 = (xmlCharEncodingHandlerPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlOutputBuffer_encoder_set" "', argument " "1"" of type '" "_xmlOutputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlOutputBuffer * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlCharEncodingHandler, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlOutputBuffer_encoder_set" "', argument " "2"" of type '" "xmlCharEncodingHandlerPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlCharEncodingHandlerPtr >(argp2);if (arg1) (arg1)->encoder = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlOutputBuffer_encoder_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlOutputBuffer *arg1 = (_xmlOutputBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlCharEncodingHandlerPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlOutputBuffer_encoder_get" "', argument " "1"" of type '" "_xmlOutputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlOutputBuffer * >(argp1);result = (xmlCharEncodingHandlerPtr) ((arg1)->encoder);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlOutputBuffer_buffer_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlOutputBuffer *arg1 = (_xmlOutputBuffer *) 0 ;
  xmlBufPtr arg2 = (xmlBufPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlOutputBuffer_buffer_set" "', argument " "1"" of type '" "_xmlOutputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlOutputBuffer * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlBuf, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlOutputBuffer_buffer_set" "', argument " "2"" of type '" "xmlBufPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlBufPtr >(argp2);if (arg1) (arg1)->buffer = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlOutputBuffer_buffer_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlOutputBuffer *arg1 = (_xmlOutputBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlBufPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlOutputBuffer_buffer_get" "', argument " "1"" of type '" "_xmlOutputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlOutputBuffer * >(argp1);result = (xmlBufPtr) ((arg1)->buffer);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlBuf, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlOutputBuffer_conv_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlOutputBuffer *arg1 = (_xmlOutputBuffer *) 0 ;
  xmlBufPtr arg2 = (xmlBufPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlOutputBuffer_conv_set" "', argument " "1"" of type '" "_xmlOutputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlOutputBuffer * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlBuf, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlOutputBuffer_conv_set" "', argument " "2"" of type '" "xmlBufPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlBufPtr >(argp2);if (arg1) (arg1)->conv = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlOutputBuffer_conv_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlOutputBuffer *arg1 = (_xmlOutputBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlBufPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlOutputBuffer_conv_get" "', argument " "1"" of type '" "_xmlOutputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlOutputBuffer * >(argp1);result = (xmlBufPtr) ((arg1)->conv);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlBuf, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlOutputBuffer_written_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlOutputBuffer *arg1 = (_xmlOutputBuffer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlOutputBuffer_written_set" "', argument " "1"" of type '" "_xmlOutputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlOutputBuffer * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlOutputBuffer_written_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->written = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlOutputBuffer_written_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlOutputBuffer *arg1 = (_xmlOutputBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlOutputBuffer_written_get" "', argument " "1"" of type '" "_xmlOutputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlOutputBuffer * >(argp1);result = (int) ((arg1)->written);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlOutputBuffer_error_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlOutputBuffer *arg1 = (_xmlOutputBuffer *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlOutputBuffer_error_set" "', argument " "1"" of type '" "_xmlOutputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlOutputBuffer * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlOutputBuffer_error_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->error = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlOutputBuffer_error_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlOutputBuffer *arg1 = (_xmlOutputBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlOutputBuffer_error_get" "', argument " "1"" of type '" "_xmlOutputBuffer *""'"); 
  }
  arg1 = reinterpret_cast< _xmlOutputBuffer * >(argp1);result = (int) ((arg1)->error);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlOutputBuffer(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlOutputBuffer *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlOutputBuffer.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlOutputBuffer.");
  result = (_xmlOutputBuffer *)new _xmlOutputBuffer();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlOutputBuffer, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlOutputBuffer(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlOutputBuffer * arg1 = (_xmlOutputBuffer *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap___xmlParserInputBufferCreateFilenameValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserInputBufferCreateFilenameFunc *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlParserInputBufferCreateFilenameValue.");
  
  result = (xmlParserInputBufferCreateFilenameFunc *)__xmlParserInputBufferCreateFilenameValue();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlOutputBufferCreateFilenameValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferCreateFilenameFunc *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlOutputBufferCreateFilenameValue.");
  
  result = (xmlOutputBufferCreateFilenameFunc *)__xmlOutputBufferCreateFilenameValue();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCleanupInputCallbacks(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCleanupInputCallbacks.");
  
  xmlCleanupInputCallbacks();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlPopInputCallbacks(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlPopInputCallbacks.");
  
  result = (int)xmlPopInputCallbacks();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRegisterDefaultInputCallbacks(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRegisterDefaultInputCallbacks.");
  
  xmlRegisterDefaultInputCallbacks();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAllocParserInputBuffer(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCharEncoding arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  xmlParserInputBufferPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAllocParserInputBuffer.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlAllocParserInputBuffer" "', argument " "1"" of type '" "xmlCharEncoding""'");
  } 
  arg1 = static_cast< xmlCharEncoding >(val1);result = (xmlParserInputBufferPtr)xmlAllocParserInputBuffer(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserInputBufferCreateFilename(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  xmlCharEncoding arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlParserInputBufferPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserInputBufferCreateFilename.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserInputBufferCreateFilename" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlParserInputBufferCreateFilename" "', argument " "2"" of type '" "xmlCharEncoding""'");
  } 
  arg2 = static_cast< xmlCharEncoding >(val2);result = (xmlParserInputBufferPtr)xmlParserInputBufferCreateFilename((char const *)arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  // free(arg1);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserInputBufferCreateFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  xmlCharEncoding arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlParserInputBufferPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserInputBufferCreateFile.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserInputBufferCreateFile" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlParserInputBufferCreateFile" "', argument " "2"" of type '" "xmlCharEncoding""'");
  } 
  arg2 = static_cast< xmlCharEncoding >(val2);result = (xmlParserInputBufferPtr)xmlParserInputBufferCreateFile(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserInputBufferCreateFd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  xmlCharEncoding arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlParserInputBufferPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserInputBufferCreateFd.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlParserInputBufferCreateFd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlParserInputBufferCreateFd" "', argument " "2"" of type '" "xmlCharEncoding""'");
  } 
  arg2 = static_cast< xmlCharEncoding >(val2);result = (xmlParserInputBufferPtr)xmlParserInputBufferCreateFd(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserInputBufferCreateMem(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  xmlCharEncoding arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlParserInputBufferPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserInputBufferCreateMem.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserInputBufferCreateMem" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlParserInputBufferCreateMem" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlParserInputBufferCreateMem" "', argument " "3"" of type '" "xmlCharEncoding""'");
  } 
  arg3 = static_cast< xmlCharEncoding >(val3);result = (xmlParserInputBufferPtr)xmlParserInputBufferCreateMem((char const *)arg1,arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  // free(arg1);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserInputBufferCreateStatic(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  xmlCharEncoding arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlParserInputBufferPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserInputBufferCreateStatic.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserInputBufferCreateStatic" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlParserInputBufferCreateStatic" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlParserInputBufferCreateStatic" "', argument " "3"" of type '" "xmlCharEncoding""'");
  } 
  arg3 = static_cast< xmlCharEncoding >(val3);result = (xmlParserInputBufferPtr)xmlParserInputBufferCreateStatic((char const *)arg1,arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  // free(arg1);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserInputBufferCreateIO(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlInputReadCallback arg1 = (xmlInputReadCallback) 0 ;
  xmlInputCloseCallback arg2 = (xmlInputCloseCallback) 0 ;
  void *arg3 = (void *) 0 ;
  xmlCharEncoding arg4 ;
  int val4 ;
  int ecode4 = 0 ;
  xmlParserInputBufferPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserInputBufferCreateIO.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p_char_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlParserInputBufferCreateIO" "', argument " "1"" of type '" "xmlInputReadCallback""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlParserInputBufferCreateIO" "', argument " "2"" of type '" "xmlInputCloseCallback""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlParserInputBufferCreateIO" "', argument " "4"" of type '" "xmlCharEncoding""'");
  } 
  arg4 = static_cast< xmlCharEncoding >(val4);result = (xmlParserInputBufferPtr)xmlParserInputBufferCreateIO(arg1,arg2,arg3,arg4);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserInputBufferRead(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserInputBufferPtr arg1 = (xmlParserInputBufferPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserInputBufferRead.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserInputBufferRead" "', argument " "1"" of type '" "xmlParserInputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserInputBufferPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlParserInputBufferRead" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlParserInputBufferRead(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserInputBufferGrow(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserInputBufferPtr arg1 = (xmlParserInputBufferPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserInputBufferGrow.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserInputBufferGrow" "', argument " "1"" of type '" "xmlParserInputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserInputBufferPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlParserInputBufferGrow" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlParserInputBufferGrow(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserInputBufferPush(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserInputBufferPtr arg1 = (xmlParserInputBufferPtr) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserInputBufferPush.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserInputBufferPush" "', argument " "1"" of type '" "xmlParserInputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserInputBufferPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlParserInputBufferPush" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlParserInputBufferPush" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }result = (int)xmlParserInputBufferPush(arg1,arg2,(char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  // free(arg3);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeParserInputBuffer(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserInputBufferPtr arg1 = (xmlParserInputBufferPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeParserInputBuffer.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeParserInputBuffer" "', argument " "1"" of type '" "xmlParserInputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserInputBufferPtr >(argp1);xmlFreeParserInputBuffer(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserGetDirectory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  char *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserGetDirectory.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserGetDirectory" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (char *)xmlParserGetDirectory((char const *)arg1);
  jsresult = SWIG_FromCharPtr((const char *)result);
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRegisterInputCallbacks(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlInputMatchCallback arg1 = (xmlInputMatchCallback) 0 ;
  xmlInputOpenCallback arg2 = (xmlInputOpenCallback) 0 ;
  xmlInputReadCallback arg3 = (xmlInputReadCallback) 0 ;
  xmlInputCloseCallback arg4 = (xmlInputCloseCallback) 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRegisterInputCallbacks.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRegisterInputCallbacks" "', argument " "1"" of type '" "xmlInputMatchCallback""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char__p_void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRegisterInputCallbacks" "', argument " "2"" of type '" "xmlInputOpenCallback""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_char_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRegisterInputCallbacks" "', argument " "3"" of type '" "xmlInputReadCallback""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[3], (void**)(&arg4), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRegisterInputCallbacks" "', argument " "4"" of type '" "xmlInputCloseCallback""'"); 
      }
    }
  }
  result = (int)xmlRegisterInputCallbacks(arg1,arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlParserInputBufferCreateFilename(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  xmlCharEncoding arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlParserInputBufferPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlParserInputBufferCreateFilename.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__xmlParserInputBufferCreateFilename" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "__xmlParserInputBufferCreateFilename" "', argument " "2"" of type '" "xmlCharEncoding""'");
  } 
  arg2 = static_cast< xmlCharEncoding >(val2);result = (xmlParserInputBufferPtr)__xmlParserInputBufferCreateFilename((char const *)arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  // free(arg1);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCleanupOutputCallbacks(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCleanupOutputCallbacks.");
  
  xmlCleanupOutputCallbacks();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlPopOutputCallbacks(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlPopOutputCallbacks.");
  
  result = (int)xmlPopOutputCallbacks();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRegisterDefaultOutputCallbacks(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRegisterDefaultOutputCallbacks.");
  
  xmlRegisterDefaultOutputCallbacks();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlAllocOutputBuffer(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCharEncodingHandlerPtr arg1 = (xmlCharEncodingHandlerPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlOutputBufferPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlAllocOutputBuffer.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlAllocOutputBuffer" "', argument " "1"" of type '" "xmlCharEncodingHandlerPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlCharEncodingHandlerPtr >(argp1);result = (xmlOutputBufferPtr)xmlAllocOutputBuffer(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlOutputBufferCreateFilename(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  xmlCharEncodingHandlerPtr arg2 = (xmlCharEncodingHandlerPtr) 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlOutputBufferPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlOutputBufferCreateFilename.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlOutputBufferCreateFilename" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlOutputBufferCreateFilename" "', argument " "2"" of type '" "xmlCharEncodingHandlerPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlCharEncodingHandlerPtr >(argp2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlOutputBufferCreateFilename" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlOutputBufferPtr)xmlOutputBufferCreateFilename((char const *)arg1,arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  // free(arg1);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlOutputBufferCreateFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  xmlCharEncodingHandlerPtr arg2 = (xmlCharEncodingHandlerPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlOutputBufferPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlOutputBufferCreateFile.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlOutputBufferCreateFile" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlOutputBufferCreateFile" "', argument " "2"" of type '" "xmlCharEncodingHandlerPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlCharEncodingHandlerPtr >(argp2);result = (xmlOutputBufferPtr)xmlOutputBufferCreateFile(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlOutputBufferCreateBuffer(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlCharEncodingHandlerPtr arg2 = (xmlCharEncodingHandlerPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlOutputBufferPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlOutputBufferCreateBuffer.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlOutputBufferCreateBuffer" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlOutputBufferCreateBuffer" "', argument " "2"" of type '" "xmlCharEncodingHandlerPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlCharEncodingHandlerPtr >(argp2);result = (xmlOutputBufferPtr)xmlOutputBufferCreateBuffer(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlOutputBufferCreateFd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  xmlCharEncodingHandlerPtr arg2 = (xmlCharEncodingHandlerPtr) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlOutputBufferPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlOutputBufferCreateFd.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlOutputBufferCreateFd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlOutputBufferCreateFd" "', argument " "2"" of type '" "xmlCharEncodingHandlerPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlCharEncodingHandlerPtr >(argp2);result = (xmlOutputBufferPtr)xmlOutputBufferCreateFd(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlOutputBufferCreateIO(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputWriteCallback arg1 = (xmlOutputWriteCallback) 0 ;
  xmlOutputCloseCallback arg2 = (xmlOutputCloseCallback) 0 ;
  void *arg3 = (void *) 0 ;
  xmlCharEncodingHandlerPtr arg4 = (xmlCharEncodingHandlerPtr) 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  xmlOutputBufferPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlOutputBufferCreateIO.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p_q_const__char_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlOutputBufferCreateIO" "', argument " "1"" of type '" "xmlOutputWriteCallback""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlOutputBufferCreateIO" "', argument " "2"" of type '" "xmlOutputCloseCallback""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlOutputBufferCreateIO" "', argument " "4"" of type '" "xmlCharEncodingHandlerPtr""'"); 
  }
  arg4 = reinterpret_cast< xmlCharEncodingHandlerPtr >(argp4);result = (xmlOutputBufferPtr)xmlOutputBufferCreateIO(arg1,arg2,arg3,arg4);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlOutputBufferGetContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferPtr arg1 = (xmlOutputBufferPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlOutputBufferGetContent.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlOutputBufferGetContent" "', argument " "1"" of type '" "xmlOutputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlOutputBufferPtr >(argp1);result = (xmlChar *)xmlOutputBufferGetContent(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlOutputBufferGetSize(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferPtr arg1 = (xmlOutputBufferPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlOutputBufferGetSize.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlOutputBufferGetSize" "', argument " "1"" of type '" "xmlOutputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlOutputBufferPtr >(argp1);result = xmlOutputBufferGetSize(arg1);
  jsresult = SWIG_From_size_t(static_cast< size_t >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlOutputBufferWrite(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferPtr arg1 = (xmlOutputBufferPtr) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlOutputBufferWrite.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlOutputBufferWrite" "', argument " "1"" of type '" "xmlOutputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlOutputBufferPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlOutputBufferWrite" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlOutputBufferWrite" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }result = (int)xmlOutputBufferWrite(arg1,arg2,(char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  // free(arg3);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlOutputBufferWriteString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferPtr arg1 = (xmlOutputBufferPtr) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlOutputBufferWriteString.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlOutputBufferWriteString" "', argument " "1"" of type '" "xmlOutputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlOutputBufferPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlOutputBufferWriteString" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (int)xmlOutputBufferWriteString(arg1,(char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlOutputBufferWriteEscape(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferPtr arg1 = (xmlOutputBufferPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlCharEncodingOutputFunc arg3 = (xmlCharEncodingOutputFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlOutputBufferWriteEscape.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlOutputBufferWriteEscape" "', argument " "1"" of type '" "xmlOutputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlOutputBufferPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlOutputBufferWriteEscape" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }{
    {
      int res = SWIG_ConvertFunctionPtr(args[2], (void**)(&arg3), SWIGTYPE_p_f_p_unsigned_char_p_int_p_q_const__unsigned_char_p_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlOutputBufferWriteEscape" "', argument " "3"" of type '" "xmlCharEncodingOutputFunc""'"); 
      }
    }
  }
  result = (int)xmlOutputBufferWriteEscape(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlOutputBufferFlush(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferPtr arg1 = (xmlOutputBufferPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlOutputBufferFlush.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlOutputBufferFlush" "', argument " "1"" of type '" "xmlOutputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlOutputBufferPtr >(argp1);result = (int)xmlOutputBufferFlush(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlOutputBufferClose(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferPtr arg1 = (xmlOutputBufferPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlOutputBufferClose.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlOutputBufferClose" "', argument " "1"" of type '" "xmlOutputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlOutputBufferPtr >(argp1);result = (int)xmlOutputBufferClose(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRegisterOutputCallbacks(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputMatchCallback arg1 = (xmlOutputMatchCallback) 0 ;
  xmlOutputOpenCallback arg2 = (xmlOutputOpenCallback) 0 ;
  xmlOutputWriteCallback arg3 = (xmlOutputWriteCallback) 0 ;
  xmlOutputCloseCallback arg4 = (xmlOutputCloseCallback) 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRegisterOutputCallbacks.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRegisterOutputCallbacks" "', argument " "1"" of type '" "xmlOutputMatchCallback""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_q_const__char__p_void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRegisterOutputCallbacks" "', argument " "2"" of type '" "xmlOutputOpenCallback""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_q_const__char_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRegisterOutputCallbacks" "', argument " "3"" of type '" "xmlOutputWriteCallback""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[3], (void**)(&arg4), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRegisterOutputCallbacks" "', argument " "4"" of type '" "xmlOutputCloseCallback""'"); 
      }
    }
  }
  result = (int)xmlRegisterOutputCallbacks(arg1,arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlOutputBufferCreateFilename(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  xmlCharEncodingHandlerPtr arg2 = (xmlCharEncodingHandlerPtr) 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlOutputBufferPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlOutputBufferCreateFilename.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__xmlOutputBufferCreateFilename" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__xmlOutputBufferCreateFilename" "', argument " "2"" of type '" "xmlCharEncodingHandlerPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlCharEncodingHandlerPtr >(argp2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__xmlOutputBufferCreateFilename" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlOutputBufferPtr)__xmlOutputBufferCreateFilename((char const *)arg1,arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  // free(arg1);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCheckHTTPInput(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlParserInputPtr arg2 = (xmlParserInputPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlParserInputPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCheckHTTPInput.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCheckHTTPInput" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCheckHTTPInput" "', argument " "2"" of type '" "xmlParserInputPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlParserInputPtr >(argp2);result = (xmlParserInputPtr)xmlCheckHTTPInput(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInput, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNoNetExternalEntityLoader(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  xmlParserCtxtPtr arg3 = (xmlParserCtxtPtr) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  xmlParserInputPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNoNetExternalEntityLoader.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNoNetExternalEntityLoader" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNoNetExternalEntityLoader" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlNoNetExternalEntityLoader" "', argument " "3"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg3 = reinterpret_cast< xmlParserCtxtPtr >(argp3);result = (xmlParserInputPtr)xmlNoNetExternalEntityLoader((char const *)arg1,(char const *)arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInput, 0 |  0 );
  // free(arg1);
  // free(arg2);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNormalizeWindowsPath(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNormalizeWindowsPath.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNormalizeWindowsPath" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlChar *)xmlNormalizeWindowsPath((unsigned char const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCheckFilename(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCheckFilename.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCheckFilename" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (int)xmlCheckFilename((char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFileMatch(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFileMatch.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFileMatch" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (int)xmlFileMatch((char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFileOpen(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  void *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFileOpen.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFileOpen" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (void *)xmlFileOpen((char const *)arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFileRead(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFileRead.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlFileRead" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlFileRead" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlFileRead(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFileClose(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFileClose.");
  
  arg1 = getSwigCObjectPtr(args[0]);result = (int)xmlFileClose(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserInputBufferCreateFilenameDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserInputBufferCreateFilenameFunc arg1 = (xmlParserInputBufferCreateFilenameFunc) 0 ;
  xmlParserInputBufferCreateFilenameFunc result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserInputBufferCreateFilenameDefault.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlParserInputBufferCreateFilenameDefault" "', argument " "1"" of type '" "xmlParserInputBufferCreateFilenameFunc""'"); 
      }
    }
  }
  result = (xmlParserInputBufferCreateFilenameFunc)xmlParserInputBufferCreateFilenameDefault(arg1);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlOutputBufferCreateFilenameDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferCreateFilenameFunc arg1 = (xmlOutputBufferCreateFilenameFunc) 0 ;
  xmlOutputBufferCreateFilenameFunc result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlOutputBufferCreateFilenameDefault.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlOutputBufferCreateFilenameDefault" "', argument " "1"" of type '" "xmlOutputBufferCreateFilenameFunc""'"); 
      }
    }
  }
  result = (xmlOutputBufferCreateFilenameFunc)xmlOutputBufferCreateFilenameDefault(arg1);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefOutputBufferCreateFilenameDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferCreateFilenameFunc arg1 = (xmlOutputBufferCreateFilenameFunc) 0 ;
  xmlOutputBufferCreateFilenameFunc result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefOutputBufferCreateFilenameDefault.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlThrDefOutputBufferCreateFilenameDefault" "', argument " "1"" of type '" "xmlOutputBufferCreateFilenameFunc""'"); 
      }
    }
  }
  result = (xmlOutputBufferCreateFilenameFunc)xmlThrDefOutputBufferCreateFilenameDefault(arg1);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefParserInputBufferCreateFilenameDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserInputBufferCreateFilenameFunc arg1 = (xmlParserInputBufferCreateFilenameFunc) 0 ;
  xmlParserInputBufferCreateFilenameFunc result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefParserInputBufferCreateFilenameDefault.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlThrDefParserInputBufferCreateFilenameDefault" "', argument " "1"" of type '" "xmlParserInputBufferCreateFilenameFunc""'"); 
      }
    }
  }
  result = (xmlParserInputBufferCreateFilenameFunc)xmlThrDefParserInputBufferCreateFilenameDefault(arg1);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2GetPublicId(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2GetPublicId.");
  
  arg1 = getSwigCObjectPtr(args[0]);result = (xmlChar *)xmlSAX2GetPublicId(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2GetSystemId(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2GetSystemId.");
  
  arg1 = getSwigCObjectPtr(args[0]);result = (xmlChar *)xmlSAX2GetSystemId(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2SetDocumentLocator(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlSAXLocatorPtr arg2 = (xmlSAXLocatorPtr) 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2SetDocumentLocator.");
  
  arg1 = getSwigCObjectPtr(args[0]);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlSAXLocator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2SetDocumentLocator" "', argument " "2"" of type '" "xmlSAXLocatorPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSAXLocatorPtr >(argp2);xmlSAX2SetDocumentLocator(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2GetLineNumber(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2GetLineNumber.");
  
  arg1 = getSwigCObjectPtr(args[0]);result = (int)xmlSAX2GetLineNumber(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2GetColumnNumber(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2GetColumnNumber.");
  
  arg1 = getSwigCObjectPtr(args[0]);result = (int)xmlSAX2GetColumnNumber(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2IsStandalone(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2IsStandalone.");
  
  arg1 = getSwigCObjectPtr(args[0]);result = (int)xmlSAX2IsStandalone(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2HasInternalSubset(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2HasInternalSubset.");
  
  arg1 = getSwigCObjectPtr(args[0]);result = (int)xmlSAX2HasInternalSubset(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2HasExternalSubset(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2HasExternalSubset.");
  
  arg1 = getSwigCObjectPtr(args[0]);result = (int)xmlSAX2HasExternalSubset(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2InternalSubset(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2InternalSubset.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2InternalSubset" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSAX2InternalSubset" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSAX2InternalSubset" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }xmlSAX2InternalSubset(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2ExternalSubset(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2ExternalSubset.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2ExternalSubset" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSAX2ExternalSubset" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSAX2ExternalSubset" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }xmlSAX2ExternalSubset(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2GetEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlEntityPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2GetEntity.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2GetEntity" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlEntityPtr)xmlSAX2GetEntity(arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlEntity);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2GetParameterEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlEntityPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2GetParameterEntity.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2GetParameterEntity" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlEntityPtr)xmlSAX2GetParameterEntity(arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlEntity);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2ResolveEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlParserInputPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2ResolveEntity.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2ResolveEntity" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSAX2ResolveEntity" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlParserInputPtr)xmlSAX2ResolveEntity(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInput, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2EntityDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  xmlChar *arg6 = (xmlChar *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  size_t size6 = 0 ;
  int alloc6 = 0 ;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2EntityDecl.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2EntityDecl" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSAX2EntityDecl" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSAX2EntityDecl" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlSAX2EntityDecl" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }if (args[5]->IsNull()) {
    arg6 = NULL;
  } else {
    res6 = SWIG_AsCharPtrAndSize(args[5], &buf6, &size6, &alloc6);
    
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlSAX2EntityDecl" "', argument " "6"" of type '" "xmlChar *""'");
    }
    
    arg6 = reinterpret_cast< xmlChar * >(buf6);
  }xmlSAX2EntityDecl(arg1,(unsigned char const *)arg2,arg3,(unsigned char const *)arg4,(unsigned char const *)arg5,arg6);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2AttributeDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int arg4 ;
  int arg5 ;
  xmlChar *arg6 = (xmlChar *) 0 ;
  xmlEnumerationPtr arg7 = (xmlEnumerationPtr) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  size_t size6 = 0 ;
  int alloc6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  
  if (args.Length() < 7 || args.Length() > 7) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2AttributeDecl.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2AttributeDecl" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSAX2AttributeDecl" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlSAX2AttributeDecl" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlSAX2AttributeDecl" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);if (args[5]->IsNull()) {
    arg6 = NULL;
  } else {
    res6 = SWIG_AsCharPtrAndSize(args[5], &buf6, &size6, &alloc6);
    
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlSAX2AttributeDecl" "', argument " "6"" of type '" "xmlChar const *""'");
    }
    
    arg6 = reinterpret_cast< xmlChar * >(buf6);
  }res7 = SWIG_ConvertPtr(args[6], &argp7,SWIGTYPE_p__xmlEnumeration, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "xmlSAX2AttributeDecl" "', argument " "7"" of type '" "xmlEnumerationPtr""'"); 
  }
  arg7 = reinterpret_cast< xmlEnumerationPtr >(argp7);xmlSAX2AttributeDecl(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,arg4,arg5,(unsigned char const *)arg6,arg7);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2ElementDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  xmlElementContentPtr arg4 = (xmlElementContentPtr) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2ElementDecl.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2ElementDecl" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSAX2ElementDecl" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSAX2ElementDecl" "', argument " "4"" of type '" "xmlElementContentPtr""'"); 
  }
  arg4 = reinterpret_cast< xmlElementContentPtr >(argp4);xmlSAX2ElementDecl(arg1,(unsigned char const *)arg2,arg3,arg4);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2NotationDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2NotationDecl.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2NotationDecl" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSAX2NotationDecl" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSAX2NotationDecl" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }xmlSAX2NotationDecl(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2UnparsedEntityDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2UnparsedEntityDecl.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2UnparsedEntityDecl" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSAX2UnparsedEntityDecl" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSAX2UnparsedEntityDecl" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlSAX2UnparsedEntityDecl" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }xmlSAX2UnparsedEntityDecl(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,(unsigned char const *)arg5);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2StartDocument(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2StartDocument.");
  
  arg1 = getSwigCObjectPtr(args[0]);xmlSAX2StartDocument(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2EndDocument(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2EndDocument.");
  
  arg1 = getSwigCObjectPtr(args[0]);xmlSAX2EndDocument(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2StartElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar **arg3 = (xmlChar **) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2StartElement.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2StartElement" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSAX2StartElement" "', argument " "3"" of type '" "xmlChar const **""'"); 
  }
  arg3 = reinterpret_cast< xmlChar ** >(argp3);xmlSAX2StartElement(arg1,(unsigned char const *)arg2,(unsigned char const **)arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2EndElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2EndElement.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2EndElement" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }xmlSAX2EndElement(arg1,(unsigned char const *)arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2StartElementNs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int arg5 ;
  xmlChar **arg6 = (xmlChar **) 0 ;
  int arg7 ;
  int arg8 ;
  xmlChar **arg9 = (xmlChar **) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  
  if (args.Length() < 9 || args.Length() > 9) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2StartElementNs.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2StartElementNs" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSAX2StartElementNs" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSAX2StartElementNs" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlSAX2StartElementNs" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);res6 = SWIG_ConvertPtr(args[5], &argp6,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlSAX2StartElementNs" "', argument " "6"" of type '" "xmlChar const **""'"); 
  }
  arg6 = reinterpret_cast< xmlChar ** >(argp6);ecode7 = SWIG_AsVal_int(args[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "xmlSAX2StartElementNs" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);ecode8 = SWIG_AsVal_int(args[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "xmlSAX2StartElementNs" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);res9 = SWIG_ConvertPtr(args[8], &argp9,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "xmlSAX2StartElementNs" "', argument " "9"" of type '" "xmlChar const **""'"); 
  }
  arg9 = reinterpret_cast< xmlChar ** >(argp9);xmlSAX2StartElementNs(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,arg5,(unsigned char const **)arg6,arg7,arg8,(unsigned char const **)arg9);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2EndElementNs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2EndElementNs.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2EndElementNs" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSAX2EndElementNs" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSAX2EndElementNs" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }xmlSAX2EndElementNs(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2Reference(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2Reference.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2Reference" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }xmlSAX2Reference(arg1,(unsigned char const *)arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2Characters(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2Characters.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2Characters" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSAX2Characters" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);xmlSAX2Characters(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2IgnorableWhitespace(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2IgnorableWhitespace.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2IgnorableWhitespace" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSAX2IgnorableWhitespace" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);xmlSAX2IgnorableWhitespace(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2ProcessingInstruction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2ProcessingInstruction.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2ProcessingInstruction" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSAX2ProcessingInstruction" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }xmlSAX2ProcessingInstruction(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2Comment(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2Comment.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2Comment" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }xmlSAX2Comment(arg1,(unsigned char const *)arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2CDataBlock(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2CDataBlock.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAX2CDataBlock" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSAX2CDataBlock" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);xmlSAX2CDataBlock(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAXDefaultVersion(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAXDefaultVersion.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlSAXDefaultVersion" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlSAXDefaultVersion(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAXVersion(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandler *arg1 = (xmlSAXHandler *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAXVersion.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSAXVersion" "', argument " "1"" of type '" "xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandler * >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlSAXVersion" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlSAXVersion(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2InitDefaultSAXHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandler *arg1 = (xmlSAXHandler *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2InitDefaultSAXHandler.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSAX2InitDefaultSAXHandler" "', argument " "1"" of type '" "xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandler * >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlSAX2InitDefaultSAXHandler" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlSAX2InitDefaultSAXHandler(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAX2InitHtmlDefaultSAXHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandler *arg1 = (xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2InitHtmlDefaultSAXHandler.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSAX2InitHtmlDefaultSAXHandler" "', argument " "1"" of type '" "xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandler * >(argp1);xmlSAX2InitHtmlDefaultSAXHandler(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlDefaultSAXHandlerInit(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlDefaultSAXHandlerInit.");
  
  htmlDefaultSAXHandlerInit();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlDefaultSAXHandlerInit(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDefaultSAXHandlerInit.");
  
  xmlDefaultSAXHandlerInit();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCheckThreadLocalStorage(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCheckThreadLocalStorage.");
  
  result = (int)xmlCheckThreadLocalStorage();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewMutex(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlMutexPtr result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewMutex.");
  
  result = (xmlMutexPtr)xmlNewMutex();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlMutex, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlMutexLock(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlMutexPtr arg1 = (xmlMutexPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMutexLock.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlMutexLock" "', argument " "1"" of type '" "xmlMutexPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlMutexPtr >(argp1);xmlMutexLock(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlMutexUnlock(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlMutexPtr arg1 = (xmlMutexPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlMutexUnlock.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlMutexUnlock" "', argument " "1"" of type '" "xmlMutexPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlMutexPtr >(argp1);xmlMutexUnlock(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeMutex(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlMutexPtr arg1 = (xmlMutexPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeMutex.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeMutex" "', argument " "1"" of type '" "xmlMutexPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlMutexPtr >(argp1);xmlFreeMutex(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewRMutex(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRMutexPtr result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewRMutex.");
  
  result = (xmlRMutexPtr)xmlNewRMutex();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlRMutex, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRMutexLock(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRMutexPtr arg1 = (xmlRMutexPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRMutexLock.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRMutexLock" "', argument " "1"" of type '" "xmlRMutexPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRMutexPtr >(argp1);xmlRMutexLock(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRMutexUnlock(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRMutexPtr arg1 = (xmlRMutexPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRMutexUnlock.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRMutexUnlock" "', argument " "1"" of type '" "xmlRMutexPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRMutexPtr >(argp1);xmlRMutexUnlock(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeRMutex(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRMutexPtr arg1 = (xmlRMutexPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeRMutex.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRMutex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeRMutex" "', argument " "1"" of type '" "xmlRMutexPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRMutexPtr >(argp1);xmlFreeRMutex(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlInitThreads(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlInitThreads.");
  
  xmlInitThreads();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlLockLibrary(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlLockLibrary.");
  
  xmlLockLibrary();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUnlockLibrary(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUnlockLibrary.");
  
  xmlUnlockLibrary();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetThreadId(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetThreadId.");
  
  result = (int)xmlGetThreadId();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlIsMainThread(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlIsMainThread.");
  
  result = (int)xmlIsMainThread();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCleanupThreads(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCleanupThreads.");
  
  xmlCleanupThreads();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_DEFAULT_VERSION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_FromCharPtr((const char *)"1.0");
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInput_buf_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  xmlParserInputBufferPtr arg2 = (xmlParserInputBufferPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_buf_set" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlParserInputBuffer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserInput_buf_set" "', argument " "2"" of type '" "xmlParserInputBufferPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlParserInputBufferPtr >(argp2);if (arg1) (arg1)->buf = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_buf_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlParserInputBufferPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_buf_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);result = (xmlParserInputBufferPtr) ((arg1)->buf);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInput_filename_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_filename_set" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserInput_filename_set" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
    arg1->filename = (char const *)reinterpret_cast< char* >(memcpy(new char[size], arg2, sizeof(char)*(size)));
  } else {
    arg1->filename = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_filename_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_filename_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);result = (char *) ((arg1)->filename);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInput_directory_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_directory_set" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserInput_directory_set" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
    arg1->directory = (char const *)reinterpret_cast< char* >(memcpy(new char[size], arg2, sizeof(char)*(size)));
  } else {
    arg1->directory = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_directory_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_directory_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);result = (char *) ((arg1)->directory);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInput_base_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_base_set" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserInput_base_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->base = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_base_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_base_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);result = (xmlChar *) ((arg1)->base);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInput_cur_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_cur_set" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserInput_cur_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->cur = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_cur_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_cur_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);result = (xmlChar *) ((arg1)->cur);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInput_end_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_end_set" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserInput_end_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->end = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_end_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_end_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);result = (xmlChar *) ((arg1)->end);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInput_length_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_length_set" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserInput_length_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->length = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_length_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_length_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);result = (int) ((arg1)->length);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInput_line_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_line_set" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserInput_line_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->line = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_line_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_line_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);result = (int) ((arg1)->line);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInput_col_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_col_set" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserInput_col_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->col = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_col_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_col_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);result = (int) ((arg1)->col);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInput_consumed_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_consumed_set" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_long(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserInput_consumed_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);if (arg1) (arg1)->consumed = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_consumed_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_consumed_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);result = (unsigned long) ((arg1)->consumed);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInput_free_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  xmlParserInputDeallocate arg2 = (xmlParserInputDeallocate) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_free_set" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlParserInput_free_set" "', argument " "2"" of type '" "xmlParserInputDeallocate""'"); 
      }
    }
  }
  if (arg1) (arg1)->free = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_free_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlParserInputDeallocate result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_free_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);result = (xmlParserInputDeallocate) ((arg1)->free);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInput_encoding_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_encoding_set" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserInput_encoding_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->encoding = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_encoding_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_encoding_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);result = (xmlChar *) ((arg1)->encoding);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInput_version_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_version_set" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserInput_version_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->version = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_version_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_version_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);result = (xmlChar *) ((arg1)->version);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInput_flags_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_flags_set" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserInput_flags_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->flags = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_flags_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_flags_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);result = (int) ((arg1)->flags);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInput_id_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_id_set" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserInput_id_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->id = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_id_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_id_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);result = (int) ((arg1)->id);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInput_parentConsumed_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_parentConsumed_set" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_long(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserInput_parentConsumed_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);if (arg1) (arg1)->parentConsumed = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_parentConsumed_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_parentConsumed_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);result = (unsigned long) ((arg1)->parentConsumed);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserInput_entity_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  xmlEntityPtr arg2 = (xmlEntityPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_entity_set" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlParserInput_entity_set', argument 2 of type 'xmlEntityPtr'"); 
  }
  arg2 = (xmlEntityPtr) arg20;if (arg1) (arg1)->entity = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_entity_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserInput *arg1 = (_xmlParserInput *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlEntityPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserInput_entity_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(argp1);result = (xmlEntityPtr) ((arg1)->entity);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlEntity);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlParserInput(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlParserInput *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlParserInput.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlParserInput.");
  result = (_xmlParserInput *)new _xmlParserInput();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlParserInput, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlParserInput(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlParserInput * arg1 = (_xmlParserInput *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlParserNodeInfo_node_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserNodeInfo *arg1 = (_xmlParserNodeInfo *) 0 ;
  _xmlNode *arg2 = (_xmlNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserNodeInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserNodeInfo_node_set" "', argument " "1"" of type '" "_xmlParserNodeInfo *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserNodeInfo * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlParserNodeInfo_node_set', argument 2 of type '_xmlNode const *'"); 
    }
  }
  
  arg2 = ((_xmlNode *) arg20);if (arg1) (arg1)->node = (_xmlNode const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserNodeInfo_node_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserNodeInfo *arg1 = (_xmlParserNodeInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlNode *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserNodeInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserNodeInfo_node_get" "', argument " "1"" of type '" "_xmlParserNodeInfo *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserNodeInfo * >(argp1);result = (_xmlNode *) ((arg1)->node);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserNodeInfo_begin_pos_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserNodeInfo *arg1 = (_xmlParserNodeInfo *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserNodeInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserNodeInfo_begin_pos_set" "', argument " "1"" of type '" "_xmlParserNodeInfo *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserNodeInfo * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_long(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserNodeInfo_begin_pos_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);if (arg1) (arg1)->begin_pos = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserNodeInfo_begin_pos_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserNodeInfo *arg1 = (_xmlParserNodeInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserNodeInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserNodeInfo_begin_pos_get" "', argument " "1"" of type '" "_xmlParserNodeInfo *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserNodeInfo * >(argp1);result = (unsigned long) ((arg1)->begin_pos);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserNodeInfo_begin_line_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserNodeInfo *arg1 = (_xmlParserNodeInfo *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserNodeInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserNodeInfo_begin_line_set" "', argument " "1"" of type '" "_xmlParserNodeInfo *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserNodeInfo * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_long(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserNodeInfo_begin_line_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);if (arg1) (arg1)->begin_line = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserNodeInfo_begin_line_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserNodeInfo *arg1 = (_xmlParserNodeInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserNodeInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserNodeInfo_begin_line_get" "', argument " "1"" of type '" "_xmlParserNodeInfo *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserNodeInfo * >(argp1);result = (unsigned long) ((arg1)->begin_line);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserNodeInfo_end_pos_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserNodeInfo *arg1 = (_xmlParserNodeInfo *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserNodeInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserNodeInfo_end_pos_set" "', argument " "1"" of type '" "_xmlParserNodeInfo *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserNodeInfo * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_long(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserNodeInfo_end_pos_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);if (arg1) (arg1)->end_pos = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserNodeInfo_end_pos_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserNodeInfo *arg1 = (_xmlParserNodeInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserNodeInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserNodeInfo_end_pos_get" "', argument " "1"" of type '" "_xmlParserNodeInfo *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserNodeInfo * >(argp1);result = (unsigned long) ((arg1)->end_pos);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserNodeInfo_end_line_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserNodeInfo *arg1 = (_xmlParserNodeInfo *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserNodeInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserNodeInfo_end_line_set" "', argument " "1"" of type '" "_xmlParserNodeInfo *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserNodeInfo * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_long(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserNodeInfo_end_line_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);if (arg1) (arg1)->end_line = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserNodeInfo_end_line_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserNodeInfo *arg1 = (_xmlParserNodeInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserNodeInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserNodeInfo_end_line_get" "', argument " "1"" of type '" "_xmlParserNodeInfo *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserNodeInfo * >(argp1);result = (unsigned long) ((arg1)->end_line);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlParserNodeInfo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlParserNodeInfo *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlParserNodeInfo.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlParserNodeInfo.");
  result = (_xmlParserNodeInfo *)new _xmlParserNodeInfo();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlParserNodeInfo, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlParserNodeInfo(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlParserNodeInfo * arg1 = (_xmlParserNodeInfo *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlParserNodeInfoSeq_maximum_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserNodeInfoSeq *arg1 = (_xmlParserNodeInfoSeq *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserNodeInfoSeq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserNodeInfoSeq_maximum_set" "', argument " "1"" of type '" "_xmlParserNodeInfoSeq *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserNodeInfoSeq * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_long(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserNodeInfoSeq_maximum_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);if (arg1) (arg1)->maximum = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserNodeInfoSeq_maximum_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserNodeInfoSeq *arg1 = (_xmlParserNodeInfoSeq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserNodeInfoSeq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserNodeInfoSeq_maximum_get" "', argument " "1"" of type '" "_xmlParserNodeInfoSeq *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserNodeInfoSeq * >(argp1);result = (unsigned long) ((arg1)->maximum);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserNodeInfoSeq_length_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserNodeInfoSeq *arg1 = (_xmlParserNodeInfoSeq *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserNodeInfoSeq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserNodeInfoSeq_length_set" "', argument " "1"" of type '" "_xmlParserNodeInfoSeq *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserNodeInfoSeq * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_long(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserNodeInfoSeq_length_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);if (arg1) (arg1)->length = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserNodeInfoSeq_length_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserNodeInfoSeq *arg1 = (_xmlParserNodeInfoSeq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserNodeInfoSeq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserNodeInfoSeq_length_get" "', argument " "1"" of type '" "_xmlParserNodeInfoSeq *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserNodeInfoSeq * >(argp1);result = (unsigned long) ((arg1)->length);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserNodeInfoSeq_buffer_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserNodeInfoSeq *arg1 = (_xmlParserNodeInfoSeq *) 0 ;
  xmlParserNodeInfo *arg2 = (xmlParserNodeInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserNodeInfoSeq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserNodeInfoSeq_buffer_set" "', argument " "1"" of type '" "_xmlParserNodeInfoSeq *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserNodeInfoSeq * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlParserNodeInfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserNodeInfoSeq_buffer_set" "', argument " "2"" of type '" "xmlParserNodeInfo *""'"); 
  }
  arg2 = reinterpret_cast< xmlParserNodeInfo * >(argp2);if (arg1) (arg1)->buffer = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserNodeInfoSeq_buffer_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserNodeInfoSeq *arg1 = (_xmlParserNodeInfoSeq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlParserNodeInfo *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserNodeInfoSeq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserNodeInfoSeq_buffer_get" "', argument " "1"" of type '" "_xmlParserNodeInfoSeq *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserNodeInfoSeq * >(argp1);result = (xmlParserNodeInfo *) ((arg1)->buffer);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserNodeInfo, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlParserNodeInfoSeq(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlParserNodeInfoSeq *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlParserNodeInfoSeq.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlParserNodeInfoSeq.");
  result = (_xmlParserNodeInfoSeq *)new _xmlParserNodeInfoSeq();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlParserNodeInfoSeq, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlParserNodeInfoSeq(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlParserNodeInfoSeq * arg1 = (_xmlParserNodeInfoSeq *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue exports_XML_PARSER_EOF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_EOF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_START_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_START));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_MISC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_MISC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_PI_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_PI));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_DTD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_DTD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_PROLOG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_PROLOG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_COMMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_COMMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_START_TAG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_START_TAG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_CONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_CONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_CDATA_SECTION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_CDATA_SECTION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_END_TAG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_END_TAG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_ENTITY_DECL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_ENTITY_DECL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_ENTITY_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_ENTITY_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_ATTRIBUTE_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_ATTRIBUTE_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_SYSTEM_LITERAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_SYSTEM_LITERAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_EPILOG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_EPILOG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_IGNORE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_IGNORE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_PUBLIC_LITERAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_PUBLIC_LITERAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_XML_DECL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_XML_DECL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_DETECT_IDS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_COMPLETE_ATTRS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(4));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SKIP_IDS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(8));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_UNKNOWN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_UNKNOWN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_DOM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_DOM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_SAX_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_SAX));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_PUSH_DOM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_PUSH_DOM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_PUSH_SAX_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_PUSH_SAX));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_READER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_READER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_sax_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  _xmlSAXHandler *arg2 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_sax_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSAXHandler, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_sax_set" "', argument " "2"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg2 = reinterpret_cast< _xmlSAXHandler * >(argp2);if (arg1) (arg1)->sax = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_sax_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlSAXHandler *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_sax_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (_xmlSAXHandler *) ((arg1)->sax);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_userData_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_userData_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->userData = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_userData_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_userData_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (void *) ((arg1)->userData);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_myDoc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_myDoc_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlParserCtxt_myDoc_set', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;if (arg1) (arg1)->myDoc = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_myDoc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlDocPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_myDoc_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlDocPtr) ((arg1)->myDoc);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_wellFormed_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_wellFormed_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_wellFormed_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->wellFormed = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_wellFormed_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_wellFormed_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->wellFormed);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_replaceEntities_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_replaceEntities_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_replaceEntities_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->replaceEntities = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_replaceEntities_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_replaceEntities_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->replaceEntities);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_version_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_version_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_version_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->version = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_version_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_version_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlChar *) ((arg1)->version);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_encoding_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_encoding_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_encoding_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->encoding = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_encoding_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_encoding_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlChar *) ((arg1)->encoding);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_standalone_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_standalone_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_standalone_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->standalone = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_standalone_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_standalone_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->standalone);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_html_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_html_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_html_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->html = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_html_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_html_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->html);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_input_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlParserInputPtr arg2 = (xmlParserInputPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_input_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlParserInput, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_input_set" "', argument " "2"" of type '" "xmlParserInputPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlParserInputPtr >(argp2);if (arg1) (arg1)->input = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_input_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlParserInputPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_input_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlParserInputPtr) ((arg1)->input);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInput, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_inputNr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_inputNr_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_inputNr_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->inputNr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_inputNr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_inputNr_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->inputNr);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_inputMax_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_inputMax_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_inputMax_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->inputMax = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_inputMax_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_inputMax_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->inputMax);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_inputTab_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlParserInputPtr *arg2 = (xmlParserInputPtr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_inputTab_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_inputTab_set" "', argument " "2"" of type '" "xmlParserInputPtr *""'"); 
  }
  arg2 = reinterpret_cast< xmlParserInputPtr * >(argp2);if (arg1) (arg1)->inputTab = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_inputTab_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlParserInputPtr *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_inputTab_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlParserInputPtr *) ((arg1)->inputTab);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__xmlParserInput, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_node_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_node_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlParserCtxt_node_set', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (arg1) (arg1)->node = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_node_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_node_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlNodePtr) ((arg1)->node);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nodeNr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodeNr_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_nodeNr_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nodeNr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nodeNr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodeNr_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->nodeNr);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nodeMax_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodeMax_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_nodeMax_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nodeMax = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nodeMax_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodeMax_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->nodeMax);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nodeTab_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlNodePtr *arg2 = (xmlNodePtr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodeTab_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_p__xmlNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_nodeTab_set" "', argument " "2"" of type '" "xmlNodePtr *""'"); 
  }
  arg2 = reinterpret_cast< xmlNodePtr * >(argp2);if (arg1) (arg1)->nodeTab = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nodeTab_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodeTab_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlNodePtr *) ((arg1)->nodeTab);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__xmlNode, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_record_info_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_record_info_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_record_info_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->record_info = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_record_info_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_record_info_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->record_info);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_node_seq_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlParserNodeInfoSeq *arg2 = (xmlParserNodeInfoSeq *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_node_seq_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlParserNodeInfoSeq, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_node_seq_set" "', argument " "2"" of type '" "xmlParserNodeInfoSeq *""'"); 
  }
  arg2 = reinterpret_cast< xmlParserNodeInfoSeq * >(argp2);if (arg1) (arg1)->node_seq = *arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_node_seq_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlParserNodeInfoSeq *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_node_seq_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlParserNodeInfoSeq *)& ((arg1)->node_seq);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserNodeInfoSeq, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_errNo_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_errNo_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_errNo_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->errNo = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_errNo_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_errNo_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->errNo);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_hasExternalSubset_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_hasExternalSubset_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_hasExternalSubset_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->hasExternalSubset = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_hasExternalSubset_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_hasExternalSubset_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->hasExternalSubset);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_hasPErefs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_hasPErefs_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_hasPErefs_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->hasPErefs = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_hasPErefs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_hasPErefs_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->hasPErefs);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_external_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_external_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_external_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->external = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_external_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_external_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->external);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_valid_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_valid_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_valid_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->valid = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_valid_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_valid_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->valid);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_validate_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_validate_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_validate_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->validate = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_validate_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_validate_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->validate);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_vctxt_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlValidCtxt *arg2 = (xmlValidCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_vctxt_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_vctxt_set" "', argument " "2"" of type '" "xmlValidCtxt *""'"); 
  }
  arg2 = reinterpret_cast< xmlValidCtxt * >(argp2);if (arg1) (arg1)->vctxt = *arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_vctxt_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlValidCtxt *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_vctxt_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlValidCtxt *)& ((arg1)->vctxt);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlValidCtxt, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_instate_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlParserInputState arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_instate_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_instate_set" "', argument " "2"" of type '" "xmlParserInputState""'");
  } 
  arg2 = static_cast< xmlParserInputState >(val2);if (arg1) (arg1)->instate = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_instate_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlParserInputState result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_instate_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlParserInputState) ((arg1)->instate);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_token_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_token_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_token_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->token = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_token_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_token_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->token);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_directory_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_directory_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_directory_set" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }delete[] arg1->directory;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->directory = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->directory = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_directory_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_directory_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (char *) ((arg1)->directory);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_name_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->name = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_name_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlChar *) ((arg1)->name);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nameNr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nameNr_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_nameNr_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nameNr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nameNr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nameNr_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->nameNr);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nameMax_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nameMax_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_nameMax_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nameMax = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nameMax_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nameMax_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->nameMax);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nameTab_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nameTab_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_nameTab_set" "', argument " "2"" of type '" "xmlChar const **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);if (arg1) (arg1)->nameTab = (xmlChar const **)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nameTab_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar **result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nameTab_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlChar **) ((arg1)->nameTab);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nbChars_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nbChars_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_long(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_nbChars_set" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);if (arg1) (arg1)->nbChars = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nbChars_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nbChars_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (long) ((arg1)->nbChars);
  jsresult = SWIG_From_long(static_cast< long >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_checkIndex_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_checkIndex_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_long(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_checkIndex_set" "', argument " "2"" of type '" "long""'");
  } 
  arg2 = static_cast< long >(val2);if (arg1) (arg1)->checkIndex = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_checkIndex_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_checkIndex_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (long) ((arg1)->checkIndex);
  jsresult = SWIG_From_long(static_cast< long >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_keepBlanks_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_keepBlanks_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_keepBlanks_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->keepBlanks = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_keepBlanks_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_keepBlanks_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->keepBlanks);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_disableSAX_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_disableSAX_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_disableSAX_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->disableSAX = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_disableSAX_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_disableSAX_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->disableSAX);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_inSubset_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_inSubset_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_inSubset_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->inSubset = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_inSubset_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_inSubset_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->inSubset);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_intSubName_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_intSubName_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_intSubName_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->intSubName = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_intSubName_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_intSubName_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlChar *) ((arg1)->intSubName);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_extSubURI_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_extSubURI_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_extSubURI_set" "', argument " "2"" of type '" "xmlChar *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->extSubURI = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_extSubURI_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_extSubURI_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlChar *) ((arg1)->extSubURI);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_extSubSystem_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_extSubSystem_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_extSubSystem_set" "', argument " "2"" of type '" "xmlChar *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->extSubSystem = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_extSubSystem_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_extSubSystem_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlChar *) ((arg1)->extSubSystem);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_space_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_space_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_space_set" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);if (arg1) (arg1)->space = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_space_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_space_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int *) ((arg1)->space);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_spaceNr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_spaceNr_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_spaceNr_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->spaceNr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_spaceNr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_spaceNr_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->spaceNr);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_spaceMax_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_spaceMax_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_spaceMax_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->spaceMax = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_spaceMax_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_spaceMax_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->spaceMax);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_spaceTab_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_spaceTab_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_spaceTab_set" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);if (arg1) (arg1)->spaceTab = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_spaceTab_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_spaceTab_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int *) ((arg1)->spaceTab);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_depth_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_depth_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_depth_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->depth = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_depth_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_depth_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->depth);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_entity_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlParserInputPtr arg2 = (xmlParserInputPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_entity_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlParserInput, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_entity_set" "', argument " "2"" of type '" "xmlParserInputPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlParserInputPtr >(argp2);if (arg1) (arg1)->entity = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_entity_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlParserInputPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_entity_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlParserInputPtr) ((arg1)->entity);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInput, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_charset_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_charset_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_charset_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->charset = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_charset_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_charset_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->charset);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nodelen_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodelen_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_nodelen_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nodelen = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nodelen_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodelen_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->nodelen);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nodemem_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodemem_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_nodemem_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nodemem = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nodemem_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodemem_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->nodemem);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_pedantic_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_pedantic_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_pedantic_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->pedantic = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_pedantic_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_pedantic_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->pedantic);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt__private_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt__private_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->_private = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt__private_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt__private_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (void *) ((arg1)->_private);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_loadsubset_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_loadsubset_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_loadsubset_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->loadsubset = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_loadsubset_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_loadsubset_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->loadsubset);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_linenumbers_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_linenumbers_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_linenumbers_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->linenumbers = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_linenumbers_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_linenumbers_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->linenumbers);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_catalogs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_catalogs_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->catalogs = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_catalogs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_catalogs_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (void *) ((arg1)->catalogs);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_recovery_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_recovery_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_recovery_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->recovery = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_recovery_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_recovery_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->recovery);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_progressive_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_progressive_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_progressive_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->progressive = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_progressive_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_progressive_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->progressive);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_dict_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlDictPtr arg2 = (xmlDictPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_dict_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlDict, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_dict_set" "', argument " "2"" of type '" "xmlDictPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlDictPtr >(argp2);if (arg1) (arg1)->dict = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_dict_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlDictPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_dict_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlDictPtr) ((arg1)->dict);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlDict, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_atts_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_atts_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_atts_set" "', argument " "2"" of type '" "xmlChar const **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);if (arg1) (arg1)->atts = (xmlChar const **)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_atts_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar **result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_atts_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlChar **) ((arg1)->atts);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_maxatts_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_maxatts_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_maxatts_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->maxatts = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_maxatts_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_maxatts_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->maxatts);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_docdict_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_docdict_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_docdict_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->docdict = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_docdict_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_docdict_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->docdict);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_str_xml_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_str_xml_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_str_xml_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->str_xml = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_str_xml_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_str_xml_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlChar *) ((arg1)->str_xml);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_str_xmlns_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_str_xmlns_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_str_xmlns_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->str_xmlns = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_str_xmlns_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_str_xmlns_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlChar *) ((arg1)->str_xmlns);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_str_xml_ns_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_str_xml_ns_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_str_xml_ns_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->str_xml_ns = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_str_xml_ns_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_str_xml_ns_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlChar *) ((arg1)->str_xml_ns);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_sax2_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_sax2_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_sax2_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->sax2 = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_sax2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_sax2_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->sax2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nsNr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nsNr_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_nsNr_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nsNr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nsNr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nsNr_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->nsNr);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nsMax_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nsMax_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_nsMax_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nsMax = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nsMax_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nsMax_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->nsMax);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nsTab_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nsTab_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_nsTab_set" "', argument " "2"" of type '" "xmlChar const **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);if (arg1) (arg1)->nsTab = (xmlChar const **)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nsTab_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar **result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nsTab_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlChar **) ((arg1)->nsTab);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_attallocs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  unsigned int *arg2 = (unsigned int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_attallocs_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_unsigned_int, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_attallocs_set" "', argument " "2"" of type '" "unsigned int *""'"); 
  }
  arg2 = reinterpret_cast< unsigned int * >(argp2);if (arg1) (arg1)->attallocs = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_attallocs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_attallocs_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (unsigned int *) ((arg1)->attallocs);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_pushTab_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlStartTag *arg2 = (xmlStartTag *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_pushTab_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlStartTag, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_pushTab_set" "', argument " "2"" of type '" "xmlStartTag *""'"); 
  }
  arg2 = reinterpret_cast< xmlStartTag * >(argp2);if (arg1) (arg1)->pushTab = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_pushTab_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlStartTag *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_pushTab_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlStartTag *) ((arg1)->pushTab);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlStartTag, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_attsDefault_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlHashTablePtr arg2 = (xmlHashTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_attsDefault_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlHashTable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_attsDefault_set" "', argument " "2"" of type '" "xmlHashTablePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlHashTablePtr >(argp2);if (arg1) (arg1)->attsDefault = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_attsDefault_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlHashTablePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_attsDefault_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlHashTablePtr) ((arg1)->attsDefault);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_attsSpecial_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlHashTablePtr arg2 = (xmlHashTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_attsSpecial_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlHashTable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_attsSpecial_set" "', argument " "2"" of type '" "xmlHashTablePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlHashTablePtr >(argp2);if (arg1) (arg1)->attsSpecial = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_attsSpecial_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlHashTablePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_attsSpecial_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlHashTablePtr) ((arg1)->attsSpecial);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nsWellFormed_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nsWellFormed_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_nsWellFormed_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nsWellFormed = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nsWellFormed_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nsWellFormed_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->nsWellFormed);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_options_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_options_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_options_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->options = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_options_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_options_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->options);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_dictNames_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_dictNames_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_dictNames_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->dictNames = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_dictNames_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_dictNames_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->dictNames);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_freeElemsNr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_freeElemsNr_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_freeElemsNr_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->freeElemsNr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_freeElemsNr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_freeElemsNr_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->freeElemsNr);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_freeElems_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_freeElems_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlParserCtxt_freeElems_set', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (arg1) (arg1)->freeElems = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_freeElems_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_freeElems_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlNodePtr) ((arg1)->freeElems);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_freeAttrsNr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_freeAttrsNr_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_freeAttrsNr_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->freeAttrsNr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_freeAttrsNr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_freeAttrsNr_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->freeAttrsNr);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_freeAttrs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlAttrPtr arg2 = (xmlAttrPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_freeAttrs_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlParserCtxt_freeAttrs_set', argument 2 of type 'xmlAttrPtr'"); 
  }
  arg2 = (xmlAttrPtr) arg20;if (arg1) (arg1)->freeAttrs = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_freeAttrs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlAttrPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_freeAttrs_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlAttrPtr) ((arg1)->freeAttrs);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlAttr);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_lastError_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlError *arg2 = (xmlError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_lastError_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_lastError_set" "', argument " "2"" of type '" "xmlError *""'"); 
  }
  arg2 = reinterpret_cast< xmlError * >(argp2);if (arg1) (arg1)->lastError = *arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_lastError_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlError *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_lastError_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlError *)& ((arg1)->lastError);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlError, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_parseMode_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlParserMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_parseMode_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_parseMode_set" "', argument " "2"" of type '" "xmlParserMode""'");
  } 
  arg2 = static_cast< xmlParserMode >(val2);if (arg1) (arg1)->parseMode = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_parseMode_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlParserMode result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_parseMode_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlParserMode) ((arg1)->parseMode);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nbentities_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nbentities_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_long(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_nbentities_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);if (arg1) (arg1)->nbentities = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nbentities_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nbentities_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (unsigned long) ((arg1)->nbentities);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_sizeentities_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_sizeentities_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_long(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_sizeentities_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);if (arg1) (arg1)->sizeentities = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_sizeentities_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_sizeentities_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (unsigned long) ((arg1)->sizeentities);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nodeInfo_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlParserNodeInfo *arg2 = (xmlParserNodeInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodeInfo_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlParserNodeInfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_nodeInfo_set" "', argument " "2"" of type '" "xmlParserNodeInfo *""'"); 
  }
  arg2 = reinterpret_cast< xmlParserNodeInfo * >(argp2);if (arg1) (arg1)->nodeInfo = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nodeInfo_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlParserNodeInfo *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodeInfo_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlParserNodeInfo *) ((arg1)->nodeInfo);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserNodeInfo, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nodeInfoNr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodeInfoNr_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_nodeInfoNr_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nodeInfoNr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nodeInfoNr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodeInfoNr_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->nodeInfoNr);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nodeInfoMax_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodeInfoMax_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_nodeInfoMax_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nodeInfoMax = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nodeInfoMax_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodeInfoMax_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->nodeInfoMax);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nodeInfoTab_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlParserNodeInfo *arg2 = (xmlParserNodeInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodeInfoTab_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlParserNodeInfo, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_nodeInfoTab_set" "', argument " "2"" of type '" "xmlParserNodeInfo *""'"); 
  }
  arg2 = reinterpret_cast< xmlParserNodeInfo * >(argp2);if (arg1) (arg1)->nodeInfoTab = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nodeInfoTab_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlParserNodeInfo *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nodeInfoTab_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlParserNodeInfo *) ((arg1)->nodeInfoTab);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserNodeInfo, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_input_id_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_input_id_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_input_id_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->input_id = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_input_id_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_input_id_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->input_id);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_sizeentcopy_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_sizeentcopy_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_long(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_sizeentcopy_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);if (arg1) (arg1)->sizeentcopy = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_sizeentcopy_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_sizeentcopy_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (unsigned long) ((arg1)->sizeentcopy);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_endCheckState_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_endCheckState_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_endCheckState_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->endCheckState = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_endCheckState_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_endCheckState_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (int) ((arg1)->endCheckState);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nbErrors_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nbErrors_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_short(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_nbErrors_set" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);if (arg1) (arg1)->nbErrors = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nbErrors_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nbErrors_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (unsigned short) ((arg1)->nbErrors);
  jsresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nbWarnings_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nbWarnings_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_short(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_nbWarnings_set" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);if (arg1) (arg1)->nbWarnings = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nbWarnings_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nbWarnings_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (unsigned short) ((arg1)->nbWarnings);
  jsresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_maxAmpl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_maxAmpl_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_maxAmpl_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);if (arg1) (arg1)->maxAmpl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_maxAmpl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_maxAmpl_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (unsigned int) ((arg1)->maxAmpl);
  jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_nsdb_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlParserNsData *arg2 = (xmlParserNsData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nsdb_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlParserNsData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_nsdb_set" "', argument " "2"" of type '" "xmlParserNsData *""'"); 
  }
  arg2 = reinterpret_cast< xmlParserNsData * >(argp2);if (arg1) (arg1)->nsdb = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_nsdb_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlParserNsData *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_nsdb_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlParserNsData *) ((arg1)->nsdb);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserNsData, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_attrHashMax_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_attrHashMax_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlParserCtxt_attrHashMax_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);if (arg1) (arg1)->attrHashMax = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_attrHashMax_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_attrHashMax_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (unsigned int) ((arg1)->attrHashMax);
  jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_attrHash_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlAttrHashBucket *arg2 = (xmlAttrHashBucket *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_attrHash_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlAttrHashBucket, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlParserCtxt_attrHash_set" "', argument " "2"" of type '" "xmlAttrHashBucket *""'"); 
  }
  arg2 = reinterpret_cast< xmlAttrHashBucket * >(argp2);if (arg1) (arg1)->attrHash = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_attrHash_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlAttrHashBucket *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_attrHash_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlAttrHashBucket *) ((arg1)->attrHash);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlAttrHashBucket, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_errorHandler_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  xmlStructuredErrorFunc arg2 = (xmlStructuredErrorFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_errorHandler_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const___xmlError__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlParserCtxt_errorHandler_set" "', argument " "2"" of type '" "xmlStructuredErrorFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->errorHandler = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_errorHandler_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlStructuredErrorFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_errorHandler_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (xmlStructuredErrorFunc) ((arg1)->errorHandler);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const___xmlError__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlParserCtxt_errorCtxt_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_errorCtxt_set" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->errorCtxt = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserCtxt_errorCtxt_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlParserCtxt *arg1 = (_xmlParserCtxt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlParserCtxt_errorCtxt_get" "', argument " "1"" of type '" "_xmlParserCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserCtxt * >(argp1);result = (void *) ((arg1)->errorCtxt);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlParserCtxt *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlParserCtxt.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlParserCtxt.");
  result = (_xmlParserCtxt *)new _xmlParserCtxt();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlParserCtxt, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlParserCtxt(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlParserCtxt * arg1 = (_xmlParserCtxt *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlSAXLocator_getPublicId_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXLocator *arg1 = (_xmlSAXLocator *) 0 ;
  xmlChar *(*arg2)(void *) = (xmlChar *(*)(void *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXLocator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXLocator_getPublicId_set" "', argument " "1"" of type '" "_xmlSAXLocator *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXLocator * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void__p_unsigned_char);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXLocator_getPublicId_set" "', argument " "2"" of type '" "xmlChar const *(*)(void *)""'"); 
      }
    }
  }
  if (arg1) (arg1)->getPublicId = (xmlChar const *(*)(void *))arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXLocator_getPublicId_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXLocator *arg1 = (_xmlSAXLocator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *(*result)(void *) = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXLocator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXLocator_getPublicId_get" "', argument " "1"" of type '" "_xmlSAXLocator *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXLocator * >(argp1);result = (xmlChar *(*)(void *)) ((arg1)->getPublicId);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__p_unsigned_char);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXLocator_getSystemId_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXLocator *arg1 = (_xmlSAXLocator *) 0 ;
  xmlChar *(*arg2)(void *) = (xmlChar *(*)(void *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXLocator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXLocator_getSystemId_set" "', argument " "1"" of type '" "_xmlSAXLocator *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXLocator * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void__p_unsigned_char);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXLocator_getSystemId_set" "', argument " "2"" of type '" "xmlChar const *(*)(void *)""'"); 
      }
    }
  }
  if (arg1) (arg1)->getSystemId = (xmlChar const *(*)(void *))arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXLocator_getSystemId_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXLocator *arg1 = (_xmlSAXLocator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *(*result)(void *) = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXLocator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXLocator_getSystemId_get" "', argument " "1"" of type '" "_xmlSAXLocator *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXLocator * >(argp1);result = (xmlChar *(*)(void *)) ((arg1)->getSystemId);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__p_unsigned_char);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXLocator_getLineNumber_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXLocator *arg1 = (_xmlSAXLocator *) 0 ;
  int (*arg2)(void *) = (int (*)(void *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXLocator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXLocator_getLineNumber_set" "', argument " "1"" of type '" "_xmlSAXLocator *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXLocator * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXLocator_getLineNumber_set" "', argument " "2"" of type '" "int (*)(void *)""'"); 
      }
    }
  }
  if (arg1) (arg1)->getLineNumber = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXLocator_getLineNumber_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXLocator *arg1 = (_xmlSAXLocator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int (*result)(void *) = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXLocator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXLocator_getLineNumber_get" "', argument " "1"" of type '" "_xmlSAXLocator *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXLocator * >(argp1);result = (int (*)(void *)) ((arg1)->getLineNumber);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__int);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXLocator_getColumnNumber_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXLocator *arg1 = (_xmlSAXLocator *) 0 ;
  int (*arg2)(void *) = (int (*)(void *)) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXLocator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXLocator_getColumnNumber_set" "', argument " "1"" of type '" "_xmlSAXLocator *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXLocator * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXLocator_getColumnNumber_set" "', argument " "2"" of type '" "int (*)(void *)""'"); 
      }
    }
  }
  if (arg1) (arg1)->getColumnNumber = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXLocator_getColumnNumber_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXLocator *arg1 = (_xmlSAXLocator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int (*result)(void *) = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXLocator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXLocator_getColumnNumber_get" "', argument " "1"" of type '" "_xmlSAXLocator *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXLocator * >(argp1);result = (int (*)(void *)) ((arg1)->getColumnNumber);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__int);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlSAXLocator(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlSAXLocator *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlSAXLocator.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlSAXLocator.");
  result = (_xmlSAXLocator *)new _xmlSAXLocator();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlSAXLocator, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlSAXLocator(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlSAXLocator * arg1 = (_xmlSAXLocator *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue exports_XML_SAX2_MAGIC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(0xDEEDBEAF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_internalSubset_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  internalSubsetSAXFunc arg2 = (internalSubsetSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_internalSubset_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_internalSubset_set" "', argument " "2"" of type '" "internalSubsetSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->internalSubset = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_internalSubset_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  internalSubsetSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_internalSubset_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (internalSubsetSAXFunc) ((arg1)->internalSubset);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_isStandalone_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  isStandaloneSAXFunc arg2 = (isStandaloneSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_isStandalone_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_isStandalone_set" "', argument " "2"" of type '" "isStandaloneSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->isStandalone = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_isStandalone_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  isStandaloneSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_isStandalone_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (isStandaloneSAXFunc) ((arg1)->isStandalone);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__int);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_hasInternalSubset_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  hasInternalSubsetSAXFunc arg2 = (hasInternalSubsetSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_hasInternalSubset_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_hasInternalSubset_set" "', argument " "2"" of type '" "hasInternalSubsetSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->hasInternalSubset = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_hasInternalSubset_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  hasInternalSubsetSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_hasInternalSubset_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (hasInternalSubsetSAXFunc) ((arg1)->hasInternalSubset);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__int);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_hasExternalSubset_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  hasExternalSubsetSAXFunc arg2 = (hasExternalSubsetSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_hasExternalSubset_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_hasExternalSubset_set" "', argument " "2"" of type '" "hasExternalSubsetSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->hasExternalSubset = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_hasExternalSubset_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  hasExternalSubsetSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_hasExternalSubset_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (hasExternalSubsetSAXFunc) ((arg1)->hasExternalSubset);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__int);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_resolveEntity_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  resolveEntitySAXFunc arg2 = (resolveEntitySAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_resolveEntity_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlParserInput);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_resolveEntity_set" "', argument " "2"" of type '" "resolveEntitySAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->resolveEntity = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_resolveEntity_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  resolveEntitySAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_resolveEntity_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (resolveEntitySAXFunc) ((arg1)->resolveEntity);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlParserInput);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_getEntity_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  getEntitySAXFunc arg2 = (getEntitySAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_getEntity_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__xmlChar__p__xmlEntity);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_getEntity_set" "', argument " "2"" of type '" "getEntitySAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->getEntity = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_getEntity_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  getEntitySAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_getEntity_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (getEntitySAXFunc) ((arg1)->getEntity);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__xmlChar__p__xmlEntity);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_entityDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  entityDeclSAXFunc arg2 = (entityDeclSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_entityDecl_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int_p_q_const__unsigned_char_p_q_const__unsigned_char_p_unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_entityDecl_set" "', argument " "2"" of type '" "entityDeclSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->entityDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_entityDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  entityDeclSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_entityDecl_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (entityDeclSAXFunc) ((arg1)->entityDecl);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int_p_q_const__unsigned_char_p_q_const__unsigned_char_p_unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_notationDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  notationDeclSAXFunc arg2 = (notationDeclSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_notationDecl_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_notationDecl_set" "', argument " "2"" of type '" "notationDeclSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->notationDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_notationDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  notationDeclSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_notationDecl_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (notationDeclSAXFunc) ((arg1)->notationDecl);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_attributeDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  attributeDeclSAXFunc arg2 = (attributeDeclSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_attributeDecl_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_int_int_p_q_const__unsigned_char_p__xmlEnumeration__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_attributeDecl_set" "', argument " "2"" of type '" "attributeDeclSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->attributeDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_attributeDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  attributeDeclSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_attributeDecl_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (attributeDeclSAXFunc) ((arg1)->attributeDecl);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_int_int_p_q_const__unsigned_char_p__xmlEnumeration__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_elementDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  elementDeclSAXFunc arg2 = (elementDeclSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_elementDecl_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int_p__xmlElementContent__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_elementDecl_set" "', argument " "2"" of type '" "elementDeclSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->elementDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_elementDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  elementDeclSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_elementDecl_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (elementDeclSAXFunc) ((arg1)->elementDecl);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int_p__xmlElementContent__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_unparsedEntityDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  unparsedEntityDeclSAXFunc arg2 = (unparsedEntityDeclSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_unparsedEntityDecl_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_unparsedEntityDecl_set" "', argument " "2"" of type '" "unparsedEntityDeclSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->unparsedEntityDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_unparsedEntityDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unparsedEntityDeclSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_unparsedEntityDecl_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (unparsedEntityDeclSAXFunc) ((arg1)->unparsedEntityDecl);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_setDocumentLocator_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  setDocumentLocatorSAXFunc arg2 = (setDocumentLocatorSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_setDocumentLocator_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p__xmlSAXLocator__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_setDocumentLocator_set" "', argument " "2"" of type '" "setDocumentLocatorSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->setDocumentLocator = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_setDocumentLocator_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  setDocumentLocatorSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_setDocumentLocator_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (setDocumentLocatorSAXFunc) ((arg1)->setDocumentLocator);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p__xmlSAXLocator__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_startDocument_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  startDocumentSAXFunc arg2 = (startDocumentSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_startDocument_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_startDocument_set" "', argument " "2"" of type '" "startDocumentSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->startDocument = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_startDocument_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  startDocumentSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_startDocument_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (startDocumentSAXFunc) ((arg1)->startDocument);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_endDocument_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  endDocumentSAXFunc arg2 = (endDocumentSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_endDocument_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_endDocument_set" "', argument " "2"" of type '" "endDocumentSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->endDocument = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_endDocument_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  endDocumentSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_endDocument_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (endDocumentSAXFunc) ((arg1)->endDocument);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_startElement_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  startElementSAXFunc arg2 = (startElementSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_startElement_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_startElement_set" "', argument " "2"" of type '" "startElementSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->startElement = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_startElement_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  startElementSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_startElement_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (startElementSAXFunc) ((arg1)->startElement);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_endElement_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  endElementSAXFunc arg2 = (endElementSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_endElement_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_endElement_set" "', argument " "2"" of type '" "endElementSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->endElement = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_endElement_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  endElementSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_endElement_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (endElementSAXFunc) ((arg1)->endElement);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_reference_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  referenceSAXFunc arg2 = (referenceSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_reference_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_reference_set" "', argument " "2"" of type '" "referenceSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->reference = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_reference_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  referenceSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_reference_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (referenceSAXFunc) ((arg1)->reference);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_characters_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  charactersSAXFunc arg2 = (charactersSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_characters_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_characters_set" "', argument " "2"" of type '" "charactersSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->characters = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_characters_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  charactersSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_characters_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (charactersSAXFunc) ((arg1)->characters);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_ignorableWhitespace_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  ignorableWhitespaceSAXFunc arg2 = (ignorableWhitespaceSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_ignorableWhitespace_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_ignorableWhitespace_set" "', argument " "2"" of type '" "ignorableWhitespaceSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->ignorableWhitespace = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_ignorableWhitespace_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ignorableWhitespaceSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_ignorableWhitespace_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (ignorableWhitespaceSAXFunc) ((arg1)->ignorableWhitespace);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_processingInstruction_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  processingInstructionSAXFunc arg2 = (processingInstructionSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_processingInstruction_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_processingInstruction_set" "', argument " "2"" of type '" "processingInstructionSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->processingInstruction = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_processingInstruction_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  processingInstructionSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_processingInstruction_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (processingInstructionSAXFunc) ((arg1)->processingInstruction);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_comment_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  commentSAXFunc arg2 = (commentSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_comment_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_comment_set" "', argument " "2"" of type '" "commentSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->comment = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_comment_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  commentSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_comment_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (commentSAXFunc) ((arg1)->comment);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_warning_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  warningSAXFunc arg2 = (warningSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_warning_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_warning_set" "', argument " "2"" of type '" "warningSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->warning = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_warning_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  warningSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_warning_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (warningSAXFunc) ((arg1)->warning);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_error_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  errorSAXFunc arg2 = (errorSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_error_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_error_set" "', argument " "2"" of type '" "errorSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->error = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_error_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  errorSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_error_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (errorSAXFunc) ((arg1)->error);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_fatalError_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  fatalErrorSAXFunc arg2 = (fatalErrorSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_fatalError_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_fatalError_set" "', argument " "2"" of type '" "fatalErrorSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->fatalError = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_fatalError_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  fatalErrorSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_fatalError_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (fatalErrorSAXFunc) ((arg1)->fatalError);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_getParameterEntity_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  getParameterEntitySAXFunc arg2 = (getParameterEntitySAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_getParameterEntity_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__xmlChar__p__xmlEntity);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_getParameterEntity_set" "', argument " "2"" of type '" "getParameterEntitySAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->getParameterEntity = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_getParameterEntity_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  getParameterEntitySAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_getParameterEntity_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (getParameterEntitySAXFunc) ((arg1)->getParameterEntity);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__xmlChar__p__xmlEntity);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_cdataBlock_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  cdataBlockSAXFunc arg2 = (cdataBlockSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_cdataBlock_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_cdataBlock_set" "', argument " "2"" of type '" "cdataBlockSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->cdataBlock = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_cdataBlock_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  cdataBlockSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_cdataBlock_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (cdataBlockSAXFunc) ((arg1)->cdataBlock);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_externalSubset_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  externalSubsetSAXFunc arg2 = (externalSubsetSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_externalSubset_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_externalSubset_set" "', argument " "2"" of type '" "externalSubsetSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->externalSubset = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_externalSubset_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  externalSubsetSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_externalSubset_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (externalSubsetSAXFunc) ((arg1)->externalSubset);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_initialized_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_initialized_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSAXHandler_initialized_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);if (arg1) (arg1)->initialized = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_initialized_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_initialized_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (unsigned int) ((arg1)->initialized);
  jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler__private_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler__private_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->_private = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler__private_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler__private_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (void *) ((arg1)->_private);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_startElementNs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  startElementNsSAX2Func arg2 = (startElementNsSAX2Func) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_startElementNs_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_int_p_p_q_const__unsigned_char_int_int_p_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_startElementNs_set" "', argument " "2"" of type '" "startElementNsSAX2Func""'"); 
      }
    }
  }
  if (arg1) (arg1)->startElementNs = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_startElementNs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  startElementNsSAX2Func result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_startElementNs_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (startElementNsSAX2Func) ((arg1)->startElementNs);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_int_p_p_q_const__unsigned_char_int_int_p_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_endElementNs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  endElementNsSAX2Func arg2 = (endElementNsSAX2Func) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_endElementNs_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_endElementNs_set" "', argument " "2"" of type '" "endElementNsSAX2Func""'"); 
      }
    }
  }
  if (arg1) (arg1)->endElementNs = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_endElementNs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  endElementNsSAX2Func result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_endElementNs_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (endElementNsSAX2Func) ((arg1)->endElementNs);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandler_serror_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  xmlStructuredErrorFunc arg2 = (xmlStructuredErrorFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_serror_set" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const___xmlError__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandler_serror_set" "', argument " "2"" of type '" "xmlStructuredErrorFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->serror = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandler_serror_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandler *arg1 = (_xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlStructuredErrorFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandler_serror_get" "', argument " "1"" of type '" "_xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandler * >(argp1);result = (xmlStructuredErrorFunc) ((arg1)->serror);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const___xmlError__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlSAXHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlSAXHandler *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlSAXHandler.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlSAXHandler.");
  result = (_xmlSAXHandler *)new _xmlSAXHandler();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlSAXHandler, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlSAXHandler(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlSAXHandler * arg1 = (_xmlSAXHandler *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlSAXHandlerV1_internalSubset_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  internalSubsetSAXFunc arg2 = (internalSubsetSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_internalSubset_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_internalSubset_set" "', argument " "2"" of type '" "internalSubsetSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->internalSubset = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_internalSubset_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  internalSubsetSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_internalSubset_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (internalSubsetSAXFunc) ((arg1)->internalSubset);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_isStandalone_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  isStandaloneSAXFunc arg2 = (isStandaloneSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_isStandalone_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_isStandalone_set" "', argument " "2"" of type '" "isStandaloneSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->isStandalone = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_isStandalone_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  isStandaloneSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_isStandalone_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (isStandaloneSAXFunc) ((arg1)->isStandalone);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__int);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_hasInternalSubset_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  hasInternalSubsetSAXFunc arg2 = (hasInternalSubsetSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_hasInternalSubset_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_hasInternalSubset_set" "', argument " "2"" of type '" "hasInternalSubsetSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->hasInternalSubset = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_hasInternalSubset_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  hasInternalSubsetSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_hasInternalSubset_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (hasInternalSubsetSAXFunc) ((arg1)->hasInternalSubset);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__int);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_hasExternalSubset_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  hasExternalSubsetSAXFunc arg2 = (hasExternalSubsetSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_hasExternalSubset_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_hasExternalSubset_set" "', argument " "2"" of type '" "hasExternalSubsetSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->hasExternalSubset = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_hasExternalSubset_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  hasExternalSubsetSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_hasExternalSubset_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (hasExternalSubsetSAXFunc) ((arg1)->hasExternalSubset);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__int);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_resolveEntity_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  resolveEntitySAXFunc arg2 = (resolveEntitySAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_resolveEntity_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlParserInput);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_resolveEntity_set" "', argument " "2"" of type '" "resolveEntitySAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->resolveEntity = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_resolveEntity_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  resolveEntitySAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_resolveEntity_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (resolveEntitySAXFunc) ((arg1)->resolveEntity);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlParserInput);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_getEntity_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  getEntitySAXFunc arg2 = (getEntitySAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_getEntity_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__xmlChar__p__xmlEntity);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_getEntity_set" "', argument " "2"" of type '" "getEntitySAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->getEntity = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_getEntity_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  getEntitySAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_getEntity_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (getEntitySAXFunc) ((arg1)->getEntity);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__xmlChar__p__xmlEntity);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_entityDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  entityDeclSAXFunc arg2 = (entityDeclSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_entityDecl_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int_p_q_const__unsigned_char_p_q_const__unsigned_char_p_unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_entityDecl_set" "', argument " "2"" of type '" "entityDeclSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->entityDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_entityDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  entityDeclSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_entityDecl_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (entityDeclSAXFunc) ((arg1)->entityDecl);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int_p_q_const__unsigned_char_p_q_const__unsigned_char_p_unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_notationDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  notationDeclSAXFunc arg2 = (notationDeclSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_notationDecl_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_notationDecl_set" "', argument " "2"" of type '" "notationDeclSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->notationDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_notationDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  notationDeclSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_notationDecl_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (notationDeclSAXFunc) ((arg1)->notationDecl);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_attributeDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  attributeDeclSAXFunc arg2 = (attributeDeclSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_attributeDecl_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_int_int_p_q_const__unsigned_char_p__xmlEnumeration__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_attributeDecl_set" "', argument " "2"" of type '" "attributeDeclSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->attributeDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_attributeDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  attributeDeclSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_attributeDecl_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (attributeDeclSAXFunc) ((arg1)->attributeDecl);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_int_int_p_q_const__unsigned_char_p__xmlEnumeration__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_elementDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  elementDeclSAXFunc arg2 = (elementDeclSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_elementDecl_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int_p__xmlElementContent__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_elementDecl_set" "', argument " "2"" of type '" "elementDeclSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->elementDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_elementDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  elementDeclSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_elementDecl_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (elementDeclSAXFunc) ((arg1)->elementDecl);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int_p__xmlElementContent__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_unparsedEntityDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  unparsedEntityDeclSAXFunc arg2 = (unparsedEntityDeclSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_unparsedEntityDecl_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_unparsedEntityDecl_set" "', argument " "2"" of type '" "unparsedEntityDeclSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->unparsedEntityDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_unparsedEntityDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unparsedEntityDeclSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_unparsedEntityDecl_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (unparsedEntityDeclSAXFunc) ((arg1)->unparsedEntityDecl);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_setDocumentLocator_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  setDocumentLocatorSAXFunc arg2 = (setDocumentLocatorSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_setDocumentLocator_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p__xmlSAXLocator__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_setDocumentLocator_set" "', argument " "2"" of type '" "setDocumentLocatorSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->setDocumentLocator = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_setDocumentLocator_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  setDocumentLocatorSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_setDocumentLocator_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (setDocumentLocatorSAXFunc) ((arg1)->setDocumentLocator);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p__xmlSAXLocator__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_startDocument_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  startDocumentSAXFunc arg2 = (startDocumentSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_startDocument_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_startDocument_set" "', argument " "2"" of type '" "startDocumentSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->startDocument = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_startDocument_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  startDocumentSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_startDocument_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (startDocumentSAXFunc) ((arg1)->startDocument);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_endDocument_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  endDocumentSAXFunc arg2 = (endDocumentSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_endDocument_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_endDocument_set" "', argument " "2"" of type '" "endDocumentSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->endDocument = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_endDocument_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  endDocumentSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_endDocument_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (endDocumentSAXFunc) ((arg1)->endDocument);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_startElement_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  startElementSAXFunc arg2 = (startElementSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_startElement_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_startElement_set" "', argument " "2"" of type '" "startElementSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->startElement = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_startElement_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  startElementSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_startElement_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (startElementSAXFunc) ((arg1)->startElement);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_endElement_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  endElementSAXFunc arg2 = (endElementSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_endElement_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_endElement_set" "', argument " "2"" of type '" "endElementSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->endElement = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_endElement_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  endElementSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_endElement_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (endElementSAXFunc) ((arg1)->endElement);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_reference_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  referenceSAXFunc arg2 = (referenceSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_reference_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_reference_set" "', argument " "2"" of type '" "referenceSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->reference = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_reference_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  referenceSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_reference_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (referenceSAXFunc) ((arg1)->reference);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_characters_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  charactersSAXFunc arg2 = (charactersSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_characters_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_characters_set" "', argument " "2"" of type '" "charactersSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->characters = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_characters_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  charactersSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_characters_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (charactersSAXFunc) ((arg1)->characters);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_ignorableWhitespace_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  ignorableWhitespaceSAXFunc arg2 = (ignorableWhitespaceSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_ignorableWhitespace_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_ignorableWhitespace_set" "', argument " "2"" of type '" "ignorableWhitespaceSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->ignorableWhitespace = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_ignorableWhitespace_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ignorableWhitespaceSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_ignorableWhitespace_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (ignorableWhitespaceSAXFunc) ((arg1)->ignorableWhitespace);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_processingInstruction_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  processingInstructionSAXFunc arg2 = (processingInstructionSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_processingInstruction_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_processingInstruction_set" "', argument " "2"" of type '" "processingInstructionSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->processingInstruction = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_processingInstruction_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  processingInstructionSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_processingInstruction_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (processingInstructionSAXFunc) ((arg1)->processingInstruction);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_comment_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  commentSAXFunc arg2 = (commentSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_comment_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_comment_set" "', argument " "2"" of type '" "commentSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->comment = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_comment_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  commentSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_comment_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (commentSAXFunc) ((arg1)->comment);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_warning_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  warningSAXFunc arg2 = (warningSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_warning_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_warning_set" "', argument " "2"" of type '" "warningSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->warning = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_warning_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  warningSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_warning_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (warningSAXFunc) ((arg1)->warning);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_error_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  errorSAXFunc arg2 = (errorSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_error_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_error_set" "', argument " "2"" of type '" "errorSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->error = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_error_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  errorSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_error_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (errorSAXFunc) ((arg1)->error);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_fatalError_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  fatalErrorSAXFunc arg2 = (fatalErrorSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_fatalError_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_fatalError_set" "', argument " "2"" of type '" "fatalErrorSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->fatalError = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_fatalError_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  fatalErrorSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_fatalError_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (fatalErrorSAXFunc) ((arg1)->fatalError);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_getParameterEntity_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  getParameterEntitySAXFunc arg2 = (getParameterEntitySAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_getParameterEntity_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__xmlChar__p__xmlEntity);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_getParameterEntity_set" "', argument " "2"" of type '" "getParameterEntitySAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->getParameterEntity = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_getParameterEntity_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  getParameterEntitySAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_getParameterEntity_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (getParameterEntitySAXFunc) ((arg1)->getParameterEntity);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__xmlChar__p__xmlEntity);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_cdataBlock_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  cdataBlockSAXFunc arg2 = (cdataBlockSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_cdataBlock_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_cdataBlock_set" "', argument " "2"" of type '" "cdataBlockSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->cdataBlock = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_cdataBlock_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  cdataBlockSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_cdataBlock_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (cdataBlockSAXFunc) ((arg1)->cdataBlock);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_externalSubset_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  externalSubsetSAXFunc arg2 = (externalSubsetSAXFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_externalSubset_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlSAXHandlerV1_externalSubset_set" "', argument " "2"" of type '" "externalSubsetSAXFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->externalSubset = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_externalSubset_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  externalSubsetSAXFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_externalSubset_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (externalSubsetSAXFunc) ((arg1)->externalSubset);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSAXHandlerV1_initialized_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_initialized_set" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSAXHandlerV1_initialized_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);if (arg1) (arg1)->initialized = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSAXHandlerV1_initialized_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSAXHandlerV1 *arg1 = (_xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSAXHandlerV1_initialized_get" "', argument " "1"" of type '" "_xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSAXHandlerV1 * >(argp1);result = (unsigned int) ((arg1)->initialized);
  jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlSAXHandlerV1(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlSAXHandlerV1 *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlSAXHandlerV1.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlSAXHandlerV1.");
  result = (_xmlSAXHandlerV1 *)new _xmlSAXHandlerV1();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlSAXHandlerV1, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlSAXHandlerV1(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlSAXHandlerV1 * arg1 = (_xmlSAXHandlerV1 *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap_xmlParserVersion_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *result = 0 ;
  
  result = (char *)(char *)xmlParserVersion;
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_oldXMLWDcompatibility_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  result = (int)(int)oldXMLWDcompatibility;
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlParserDebugEntities_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  result = (int)(int)xmlParserDebugEntities;
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlDefaultSAXLocator_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXLocator *result = 0 ;
  
  result = (xmlSAXLocator *)&xmlDefaultSAXLocator;
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSAXLocator, 0 |  0 );
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlDefaultSAXHandler_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerV1 *result = 0 ;
  
  result = (xmlSAXHandlerV1 *)&xmlDefaultSAXHandler;
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap___xmlParserVersion(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char **result = 0 ;
  char *temp ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlParserVersion.");
  
  result = (char **)__xmlParserVersion();
  {
    temp = (char*) result;
    jsresult = SWIGV8_STRING_NEW2(temp, strlen(temp));
  }
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___oldXMLWDcompatibility(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___oldXMLWDcompatibility.");
  
  result = (int *)__oldXMLWDcompatibility();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlParserDebugEntities(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlParserDebugEntities.");
  
  result = (int *)__xmlParserDebugEntities();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlDefaultSAXLocator(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXLocator *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlDefaultSAXLocator.");
  
  result = (xmlSAXLocator *)__xmlDefaultSAXLocator();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSAXLocator, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlDefaultSAXHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerV1 *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlDefaultSAXHandler.");
  
  result = (xmlSAXHandlerV1 *)__xmlDefaultSAXHandler();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlDoValidityCheckingDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlDoValidityCheckingDefaultValue.");
  
  result = (int *)__xmlDoValidityCheckingDefaultValue();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlGetWarningsDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlGetWarningsDefaultValue.");
  
  result = (int *)__xmlGetWarningsDefaultValue();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlKeepBlanksDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlKeepBlanksDefaultValue.");
  
  result = (int *)__xmlKeepBlanksDefaultValue();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlLineNumbersDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlLineNumbersDefaultValue.");
  
  result = (int *)__xmlLineNumbersDefaultValue();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlLoadExtDtdDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlLoadExtDtdDefaultValue.");
  
  result = (int *)__xmlLoadExtDtdDefaultValue();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlPedanticParserDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlPedanticParserDefaultValue.");
  
  result = (int *)__xmlPedanticParserDefaultValue();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlSubstituteEntitiesDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlSubstituteEntitiesDefaultValue.");
  
  result = (int *)__xmlSubstituteEntitiesDefaultValue();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlIndentTreeOutput(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlIndentTreeOutput.");
  
  result = (int *)__xmlIndentTreeOutput();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlTreeIndentString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char **result = 0 ;
  char *temp ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlTreeIndentString.");
  
  result = (char **)__xmlTreeIndentString();
  {
    temp = (char*) result;
    jsresult = SWIGV8_STRING_NEW2(temp, strlen(temp));
  }
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap___xmlSaveNoEmptyTags(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___xmlSaveNoEmptyTags.");
  
  result = (int *)__xmlSaveNoEmptyTags();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlInitParser(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlInitParser.");
  
  xmlInitParser();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCleanupParser(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCleanupParser.");
  
  xmlCleanupParser();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlInitGlobals(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlInitGlobals.");
  
  xmlInitGlobals();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCleanupGlobals(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCleanupGlobals.");
  
  xmlCleanupGlobals();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserInputRead(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserInputPtr arg1 = (xmlParserInputPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserInputRead.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserInputRead" "', argument " "1"" of type '" "xmlParserInputPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserInputPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlParserInputRead" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlParserInputRead(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserInputGrow(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserInputPtr arg1 = (xmlParserInputPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserInputGrow.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserInputGrow" "', argument " "1"" of type '" "xmlParserInputPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserInputPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlParserInputGrow" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlParserInputGrow(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseDoc.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseDoc" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlDocPtr)xmlParseDoc((unsigned char const *)arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseFile.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseFile" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (xmlDocPtr)xmlParseFile((char const *)arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseMemory.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseMemory" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlParseMemory" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlDocPtr)xmlParseMemory((char const *)arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  // free(arg1);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSubstituteEntitiesDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSubstituteEntitiesDefault.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlSubstituteEntitiesDefault" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlSubstituteEntitiesDefault(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefSubstituteEntitiesDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefSubstituteEntitiesDefaultValue.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlThrDefSubstituteEntitiesDefaultValue" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlThrDefSubstituteEntitiesDefaultValue(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlKeepBlanksDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlKeepBlanksDefault.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlKeepBlanksDefault" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlKeepBlanksDefault(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefKeepBlanksDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefKeepBlanksDefaultValue.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlThrDefKeepBlanksDefaultValue" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlThrDefKeepBlanksDefaultValue(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStopParser(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStopParser.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStopParser" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlStopParser(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlPedanticParserDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlPedanticParserDefault.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlPedanticParserDefault" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlPedanticParserDefault(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefPedanticParserDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefPedanticParserDefaultValue.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlThrDefPedanticParserDefaultValue" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlThrDefPedanticParserDefaultValue(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlLineNumbersDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlLineNumbersDefault.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlLineNumbersDefault" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlLineNumbersDefault(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefLineNumbersDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefLineNumbersDefaultValue.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlThrDefLineNumbersDefaultValue" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlThrDefLineNumbersDefaultValue(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefDoValidityCheckingDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefDoValidityCheckingDefaultValue.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlThrDefDoValidityCheckingDefaultValue" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlThrDefDoValidityCheckingDefaultValue(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefGetWarningsDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefGetWarningsDefaultValue.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlThrDefGetWarningsDefaultValue" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlThrDefGetWarningsDefaultValue(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefLoadExtDtdDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefLoadExtDtdDefaultValue.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlThrDefLoadExtDtdDefaultValue" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlThrDefLoadExtDtdDefaultValue(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefParserDebugEntities(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefParserDebugEntities.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlThrDefParserDebugEntities" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlThrDefParserDebugEntities(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRecoverDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRecoverDoc.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRecoverDoc" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlDocPtr)xmlRecoverDoc((unsigned char const *)arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRecoverMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRecoverMemory.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRecoverMemory" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlRecoverMemory" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlDocPtr)xmlRecoverMemory((char const *)arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  // free(arg1);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRecoverFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRecoverFile.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRecoverFile" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (xmlDocPtr)xmlRecoverFile((char const *)arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseDocument(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseDocument.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseDocument" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (int)xmlParseDocument(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseExtParsedEnt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseExtParsedEnt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseExtParsedEnt" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (int)xmlParseExtParsedEnt(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAXUserParseFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerPtr arg1 = (xmlSAXHandlerPtr) 0 ;
  void *arg2 = (void *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAXUserParseFile.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSAXUserParseFile" "', argument " "1"" of type '" "xmlSAXHandlerPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandlerPtr >(argp1);arg2 = getSwigCObjectPtr(args[1]);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSAXUserParseFile" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }result = (int)xmlSAXUserParseFile(arg1,arg2,(char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  // free(arg3);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAXUserParseMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerPtr arg1 = (xmlSAXHandlerPtr) 0 ;
  void *arg2 = (void *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAXUserParseMemory.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSAXUserParseMemory" "', argument " "1"" of type '" "xmlSAXHandlerPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandlerPtr >(argp1);arg2 = getSwigCObjectPtr(args[1]);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSAXUserParseMemory" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlSAXUserParseMemory" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (int)xmlSAXUserParseMemory(arg1,arg2,(char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  // free(arg3);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAXParseDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerPtr arg1 = (xmlSAXHandlerPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAXParseDoc.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSAXParseDoc" "', argument " "1"" of type '" "xmlSAXHandlerPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandlerPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAXParseDoc" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSAXParseDoc" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlDocPtr)xmlSAXParseDoc(arg1,(unsigned char const *)arg2,arg3);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAXParseMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerPtr arg1 = (xmlSAXHandlerPtr) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAXParseMemory.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSAXParseMemory" "', argument " "1"" of type '" "xmlSAXHandlerPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandlerPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAXParseMemory" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSAXParseMemory" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlSAXParseMemory" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (xmlDocPtr)xmlSAXParseMemory(arg1,(char const *)arg2,arg3,arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  // free(arg2);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAXParseMemoryWithData(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerPtr arg1 = (xmlSAXHandlerPtr) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int arg4 ;
  void *arg5 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAXParseMemoryWithData.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSAXParseMemoryWithData" "', argument " "1"" of type '" "xmlSAXHandlerPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandlerPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAXParseMemoryWithData" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSAXParseMemoryWithData" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlSAXParseMemoryWithData" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);arg5 = getSwigCObjectPtr(args[4]);result = (xmlDocPtr)xmlSAXParseMemoryWithData(arg1,(char const *)arg2,arg3,arg4,arg5);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  // free(arg2);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAXParseFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerPtr arg1 = (xmlSAXHandlerPtr) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAXParseFile.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSAXParseFile" "', argument " "1"" of type '" "xmlSAXHandlerPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandlerPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAXParseFile" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSAXParseFile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlDocPtr)xmlSAXParseFile(arg1,(char const *)arg2,arg3);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  // free(arg2);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAXParseFileWithData(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerPtr arg1 = (xmlSAXHandlerPtr) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAXParseFileWithData.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSAXParseFileWithData" "', argument " "1"" of type '" "xmlSAXHandlerPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandlerPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAXParseFileWithData" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSAXParseFileWithData" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);arg4 = getSwigCObjectPtr(args[3]);result = (xmlDocPtr)xmlSAXParseFileWithData(arg1,(char const *)arg2,arg3,arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  // free(arg2);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAXParseEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerPtr arg1 = (xmlSAXHandlerPtr) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAXParseEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSAXParseEntity" "', argument " "1"" of type '" "xmlSAXHandlerPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandlerPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAXParseEntity" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (xmlDocPtr)xmlSAXParseEntity(arg1,(char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseEntity.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseEntity" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (xmlDocPtr)xmlParseEntity((char const *)arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSAXParseDTD(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerPtr arg1 = (xmlSAXHandlerPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlDtdPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAXParseDTD.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSAXParseDTD" "', argument " "1"" of type '" "xmlSAXHandlerPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandlerPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSAXParseDTD" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSAXParseDTD" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlDtdPtr)xmlSAXParseDTD(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDtd);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseDTD(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlDtdPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseDTD.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseDTD" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParseDTD" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlDtdPtr)xmlParseDTD((unsigned char const *)arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDtd);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlIOParseDTD(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerPtr arg1 = (xmlSAXHandlerPtr) 0 ;
  xmlParserInputBufferPtr arg2 = (xmlParserInputBufferPtr) 0 ;
  xmlCharEncoding arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlDtdPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlIOParseDTD.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlIOParseDTD" "', argument " "1"" of type '" "xmlSAXHandlerPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandlerPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlIOParseDTD" "', argument " "2"" of type '" "xmlParserInputBufferPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlParserInputBufferPtr >(argp2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlIOParseDTD" "', argument " "3"" of type '" "xmlCharEncoding""'");
  } 
  arg3 = static_cast< xmlCharEncoding >(val3);result = (xmlDtdPtr)xmlIOParseDTD(arg1,arg2,arg3);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDtd);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseBalancedChunkMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlSAXHandlerPtr arg2 = (xmlSAXHandlerPtr) 0 ;
  void *arg3 = (void *) 0 ;
  int arg4 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  xmlNodePtr *arg6 = (xmlNodePtr *) 0 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseBalancedChunkMemory.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlParseBalancedChunkMemory', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParseBalancedChunkMemory" "', argument " "2"" of type '" "xmlSAXHandlerPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSAXHandlerPtr >(argp2);arg3 = getSwigCObjectPtr(args[2]);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlParseBalancedChunkMemory" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlParseBalancedChunkMemory" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }res6 = SWIG_ConvertPtr(args[5], &argp6,SWIGTYPE_p_p__xmlNode, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlParseBalancedChunkMemory" "', argument " "6"" of type '" "xmlNodePtr *""'"); 
  }
  arg6 = reinterpret_cast< xmlNodePtr * >(argp6);result = (int)xmlParseBalancedChunkMemory(arg1,arg2,arg3,arg4,(unsigned char const *)arg5,arg6);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseInNodeContext(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int arg4 ;
  xmlNodePtr *arg5 = (xmlNodePtr *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  xmlParserErrors result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseInNodeContext.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlParseInNodeContext', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParseInNodeContext" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlParseInNodeContext" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlParseInNodeContext" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);res5 = SWIG_ConvertPtr(args[4], &argp5,SWIGTYPE_p_p__xmlNode, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlParseInNodeContext" "', argument " "5"" of type '" "xmlNodePtr *""'"); 
  }
  arg5 = reinterpret_cast< xmlNodePtr * >(argp5);result = (xmlParserErrors)xmlParseInNodeContext(arg1,(char const *)arg2,arg3,arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseBalancedChunkMemoryRecover(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlSAXHandlerPtr arg2 = (xmlSAXHandlerPtr) 0 ;
  void *arg3 = (void *) 0 ;
  int arg4 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  xmlNodePtr *arg6 = (xmlNodePtr *) 0 ;
  int arg7 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int result;
  
  if (args.Length() < 7 || args.Length() > 7) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseBalancedChunkMemoryRecover.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlParseBalancedChunkMemoryRecover', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParseBalancedChunkMemoryRecover" "', argument " "2"" of type '" "xmlSAXHandlerPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSAXHandlerPtr >(argp2);arg3 = getSwigCObjectPtr(args[2]);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlParseBalancedChunkMemoryRecover" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlParseBalancedChunkMemoryRecover" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }res6 = SWIG_ConvertPtr(args[5], &argp6,SWIGTYPE_p_p__xmlNode, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlParseBalancedChunkMemoryRecover" "', argument " "6"" of type '" "xmlNodePtr *""'"); 
  }
  arg6 = reinterpret_cast< xmlNodePtr * >(argp6);ecode7 = SWIG_AsVal_int(args[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "xmlParseBalancedChunkMemoryRecover" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);result = (int)xmlParseBalancedChunkMemoryRecover(arg1,arg2,arg3,arg4,(unsigned char const *)arg5,arg6,arg7);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseExternalEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlSAXHandlerPtr arg2 = (xmlSAXHandlerPtr) 0 ;
  void *arg3 = (void *) 0 ;
  int arg4 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  xmlChar *arg6 = (xmlChar *) 0 ;
  xmlNodePtr *arg7 = (xmlNodePtr *) 0 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  size_t size6 = 0 ;
  int alloc6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int result;
  
  if (args.Length() < 7 || args.Length() > 7) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseExternalEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlParseExternalEntity', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParseExternalEntity" "', argument " "2"" of type '" "xmlSAXHandlerPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSAXHandlerPtr >(argp2);arg3 = getSwigCObjectPtr(args[2]);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlParseExternalEntity" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlParseExternalEntity" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }if (args[5]->IsNull()) {
    arg6 = NULL;
  } else {
    res6 = SWIG_AsCharPtrAndSize(args[5], &buf6, &size6, &alloc6);
    
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlParseExternalEntity" "', argument " "6"" of type '" "xmlChar const *""'");
    }
    
    arg6 = reinterpret_cast< xmlChar * >(buf6);
  }res7 = SWIG_ConvertPtr(args[6], &argp7,SWIGTYPE_p_p__xmlNode, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "xmlParseExternalEntity" "', argument " "7"" of type '" "xmlNodePtr *""'"); 
  }
  arg7 = reinterpret_cast< xmlNodePtr * >(argp7);result = (int)xmlParseExternalEntity(arg1,arg2,arg3,arg4,(unsigned char const *)arg5,(unsigned char const *)arg6,arg7);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseCtxtExternalEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlNodePtr *arg4 = (xmlNodePtr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseCtxtExternalEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseCtxtExternalEntity" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParseCtxtExternalEntity" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlParseCtxtExternalEntity" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_p__xmlNode, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlParseCtxtExternalEntity" "', argument " "4"" of type '" "xmlNodePtr *""'"); 
  }
  arg4 = reinterpret_cast< xmlNodePtr * >(argp4);result = (int)xmlParseCtxtExternalEntity(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewParserCtxt.");
  
  result = (xmlParserCtxtPtr)xmlNewParserCtxt();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewSAXParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandler *arg1 = (xmlSAXHandler *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlParserCtxtPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewSAXParserCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewSAXParserCtxt" "', argument " "1"" of type '" "xmlSAXHandler const *""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandler * >(argp1);arg2 = getSwigCObjectPtr(args[1]);result = (xmlParserCtxtPtr)xmlNewSAXParserCtxt((_xmlSAXHandler const *)arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlInitParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlInitParserCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlInitParserCtxt" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (int)xmlInitParserCtxt(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlClearParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlClearParserCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlClearParserCtxt" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlClearParserCtxt(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeParserCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeParserCtxt" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlFreeParserCtxt(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSetupParserForBuffer(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSetupParserForBuffer.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSetupParserForBuffer" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSetupParserForBuffer" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSetupParserForBuffer" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }xmlSetupParserForBuffer(arg1,(unsigned char const *)arg2,(char const *)arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  // free(arg3);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCreateDocParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlParserCtxtPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCreateDocParserCtxt.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCreateDocParserCtxt" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlParserCtxtPtr)xmlCreateDocParserCtxt((unsigned char const *)arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCreatePushParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerPtr arg1 = (xmlSAXHandlerPtr) 0 ;
  void *arg2 = (void *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  char *arg5 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  xmlParserCtxtPtr result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCreatePushParserCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCreatePushParserCtxt" "', argument " "1"" of type '" "xmlSAXHandlerPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandlerPtr >(argp1);arg2 = getSwigCObjectPtr(args[1]);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlCreatePushParserCtxt" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlCreatePushParserCtxt" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);if (args[4]->IsNull()) {
    arg5 = NULL;
  } else if (node::Buffer::HasInstance(args[4])) {
    arg5 = node::Buffer::Data(Nan::To<v8::Object>(args[4]).ToLocalChecked());
    // printf("data: %s - %i\n", arg5, strlen(arg5));
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlCreatePushParserCtxt" "', argument " "5"" of type '" "char const *""'");
    }
    
    arg5 = reinterpret_cast< char * >(buf5);
  }result = (xmlParserCtxtPtr)xmlCreatePushParserCtxt(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  
  
  // free(arg3);
  
  // free(arg5);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseChunk(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseChunk.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseChunk" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParseChunk" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlParseChunk" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlParseChunk" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (int)xmlParseChunk(arg1,(char const *)arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCreateIOParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerPtr arg1 = (xmlSAXHandlerPtr) 0 ;
  void *arg2 = (void *) 0 ;
  xmlInputReadCallback arg3 = (xmlInputReadCallback) 0 ;
  xmlInputCloseCallback arg4 = (xmlInputCloseCallback) 0 ;
  void *arg5 = (void *) 0 ;
  xmlCharEncoding arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  xmlParserCtxtPtr result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCreateIOParserCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCreateIOParserCtxt" "', argument " "1"" of type '" "xmlSAXHandlerPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandlerPtr >(argp1);arg2 = getSwigCObjectPtr(args[1]);{
    {
      int res = SWIG_ConvertFunctionPtr(args[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_char_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlCreateIOParserCtxt" "', argument " "3"" of type '" "xmlInputReadCallback""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[3], (void**)(&arg4), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlCreateIOParserCtxt" "', argument " "4"" of type '" "xmlInputCloseCallback""'"); 
      }
    }
  }
  arg5 = getSwigCObjectPtr(args[4]);ecode6 = SWIG_AsVal_int(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xmlCreateIOParserCtxt" "', argument " "6"" of type '" "xmlCharEncoding""'");
  } 
  arg6 = static_cast< xmlCharEncoding >(val6);result = (xmlParserCtxtPtr)xmlCreateIOParserCtxt(arg1,arg2,arg3,arg4,arg5,arg6);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewIOInputStream(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlParserInputBufferPtr arg2 = (xmlParserInputBufferPtr) 0 ;
  xmlCharEncoding arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlParserInputPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewIOInputStream.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewIOInputStream" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewIOInputStream" "', argument " "2"" of type '" "xmlParserInputBufferPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlParserInputBufferPtr >(argp2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlNewIOInputStream" "', argument " "3"" of type '" "xmlCharEncoding""'");
  } 
  arg3 = static_cast< xmlCharEncoding >(val3);result = (xmlParserInputPtr)xmlNewIOInputStream(arg1,arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInput, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserFindNodeInfo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlParserNodeInfo *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserFindNodeInfo.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserFindNodeInfo" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlParserFindNodeInfo', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlParserNodeInfo *)xmlParserFindNodeInfo(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserNodeInfo, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlInitNodeInfoSeq(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserNodeInfoSeqPtr arg1 = (xmlParserNodeInfoSeqPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlInitNodeInfoSeq.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserNodeInfoSeq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlInitNodeInfoSeq" "', argument " "1"" of type '" "xmlParserNodeInfoSeqPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserNodeInfoSeqPtr >(argp1);xmlInitNodeInfoSeq(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlClearNodeInfoSeq(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserNodeInfoSeqPtr arg1 = (xmlParserNodeInfoSeqPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlClearNodeInfoSeq.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserNodeInfoSeq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlClearNodeInfoSeq" "', argument " "1"" of type '" "xmlParserNodeInfoSeqPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserNodeInfoSeqPtr >(argp1);xmlClearNodeInfoSeq(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserFindNodeInfoIndex(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserNodeInfoSeqPtr arg1 = (xmlParserNodeInfoSeqPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  unsigned long result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserFindNodeInfoIndex.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserNodeInfoSeq, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserFindNodeInfoIndex" "', argument " "1"" of type '" "xmlParserNodeInfoSeqPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserNodeInfoSeqPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlParserFindNodeInfoIndex', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (unsigned long)xmlParserFindNodeInfoIndex(arg1,arg2);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserAddNodeInfo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlParserNodeInfoPtr arg2 = (xmlParserNodeInfoPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserAddNodeInfo.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserAddNodeInfo" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlParserNodeInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParserAddNodeInfo" "', argument " "2"" of type '" "xmlParserNodeInfoPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlParserNodeInfoPtr >(argp2);xmlParserAddNodeInfo(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSetExternalEntityLoader(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlExternalEntityLoader arg1 = (xmlExternalEntityLoader) 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSetExternalEntityLoader.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_xmlParserCtxtPtr__p__xmlParserInput);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlSetExternalEntityLoader" "', argument " "1"" of type '" "xmlExternalEntityLoader""'"); 
      }
    }
  }
  xmlSetExternalEntityLoader(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetExternalEntityLoader(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlExternalEntityLoader result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetExternalEntityLoader.");
  
  result = (xmlExternalEntityLoader)xmlGetExternalEntityLoader();
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_p_q_const__char_xmlParserCtxtPtr__p__xmlParserInput);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlLoadExternalEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  xmlParserCtxtPtr arg3 = (xmlParserCtxtPtr) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  xmlParserInputPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlLoadExternalEntity.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlLoadExternalEntity" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlLoadExternalEntity" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlLoadExternalEntity" "', argument " "3"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg3 = reinterpret_cast< xmlParserCtxtPtr >(argp3);result = (xmlParserInputPtr)xmlLoadExternalEntity((char const *)arg1,(char const *)arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInput, 0 |  0 );
  // free(arg1);
  // free(arg2);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlByteConsumed(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlByteConsumed.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlByteConsumed" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (long)xmlByteConsumed(arg1);
  jsresult = SWIG_From_long(static_cast< long >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_PARSE_RECOVER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_RECOVER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_NOENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_NOENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_DTDLOAD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_DTDLOAD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_DTDATTR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_DTDATTR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_DTDVALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_DTDVALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_NOERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_NOERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_NOWARNING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_NOWARNING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_PEDANTIC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_PEDANTIC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_NOBLANKS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_NOBLANKS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_SAX1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_SAX1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_XINCLUDE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_XINCLUDE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_NONET_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_NONET));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_NODICT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_NODICT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_NSCLEAN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_NSCLEAN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_NOCDATA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_NOCDATA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_NOXINCNODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_NOXINCNODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_COMPACT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_COMPACT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_OLD10_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_OLD10));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_NOBASEFIX_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_NOBASEFIX));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_HUGE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_HUGE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_OLDSAX_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_OLDSAX));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_IGNORE_ENC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_IGNORE_ENC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_BIG_LINES_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_BIG_LINES));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSE_NO_XXE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSE_NO_XXE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlCtxtReset(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCtxtReset.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCtxtReset" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlCtxtReset(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCtxtResetPush(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCtxtResetPush.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCtxtResetPush" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCtxtResetPush" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlCtxtResetPush" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlCtxtResetPush" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else if (node::Buffer::HasInstance(args[4])) {
    arg5 = node::Buffer::Data(Nan::To<v8::Object>(args[4]).ToLocalChecked());
    // printf("data: %s - %i\n", arg5, strlen(arg5));
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlCtxtResetPush" "', argument " "5"" of type '" "char const *""'");
    }
    
    arg5 = reinterpret_cast< char * >(buf5);
  }result = (int)xmlCtxtResetPush(arg1,(char const *)arg2,arg3,(char const *)arg4,(char const *)arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  // free(arg4);
  // free(arg5);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCtxtSetOptions(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCtxtSetOptions.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCtxtSetOptions" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlCtxtSetOptions" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlCtxtSetOptions(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCtxtUseOptions(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCtxtUseOptions.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCtxtUseOptions" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlCtxtUseOptions" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlCtxtUseOptions(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCtxtSetErrorHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlStructuredErrorFunc arg2 = (xmlStructuredErrorFunc) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCtxtSetErrorHandler.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCtxtSetErrorHandler" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const___xmlError__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlCtxtSetErrorHandler" "', argument " "2"" of type '" "xmlStructuredErrorFunc""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);xmlCtxtSetErrorHandler(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCtxtSetMaxAmplification(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCtxtSetMaxAmplification.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCtxtSetMaxAmplification" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlCtxtSetMaxAmplification" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);xmlCtxtSetMaxAmplification(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReadDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReadDoc.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlReadDoc" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlReadDoc" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlReadDoc" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlReadDoc" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (xmlDocPtr)xmlReadDoc((unsigned char const *)arg1,(char const *)arg2,(char const *)arg3,arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  // free(arg2);
  // free(arg3);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReadFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReadFile.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlReadFile" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlReadFile" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlReadFile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlDocPtr)xmlReadFile((char const *)arg1,(char const *)arg2,arg3);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  // free(arg1);
  // free(arg2);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReadMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int arg5 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReadMemory.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlReadMemory" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlReadMemory" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlReadMemory" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlReadMemory" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlReadMemory" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);result = (xmlDocPtr)xmlReadMemory((char const *)arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  // free(arg1);
  
  // free(arg3);
  // free(arg4);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReadFd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReadFd.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlReadFd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlReadFd" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlReadFd" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlReadFd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (xmlDocPtr)xmlReadFd(arg1,(char const *)arg2,(char const *)arg3,arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  // free(arg2);
  // free(arg3);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReadIO(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlInputReadCallback arg1 = (xmlInputReadCallback) 0 ;
  xmlInputCloseCallback arg2 = (xmlInputCloseCallback) 0 ;
  void *arg3 = (void *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  int arg6 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReadIO.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p_char_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlReadIO" "', argument " "1"" of type '" "xmlInputReadCallback""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlReadIO" "', argument " "2"" of type '" "xmlInputCloseCallback""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlReadIO" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else if (node::Buffer::HasInstance(args[4])) {
    arg5 = node::Buffer::Data(Nan::To<v8::Object>(args[4]).ToLocalChecked());
    // printf("data: %s - %i\n", arg5, strlen(arg5));
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlReadIO" "', argument " "5"" of type '" "char const *""'");
    }
    
    arg5 = reinterpret_cast< char * >(buf5);
  }ecode6 = SWIG_AsVal_int(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xmlReadIO" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);result = (xmlDocPtr)xmlReadIO(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5,arg6);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  
  // free(arg4);
  // free(arg5);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCtxtParseDocument(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlParserInputPtr arg2 = (xmlParserInputPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCtxtParseDocument.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCtxtParseDocument" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCtxtParseDocument" "', argument " "2"" of type '" "xmlParserInputPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlParserInputPtr >(argp2);result = (xmlDocPtr)xmlCtxtParseDocument(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCtxtReadDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCtxtReadDoc.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCtxtReadDoc" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCtxtReadDoc" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlCtxtReadDoc" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlCtxtReadDoc" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlCtxtReadDoc" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);result = (xmlDocPtr)xmlCtxtReadDoc(arg1,(unsigned char const *)arg2,(char const *)arg3,(char const *)arg4,arg5);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  // free(arg3);
  // free(arg4);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCtxtReadFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCtxtReadFile.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCtxtReadFile" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCtxtReadFile" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlCtxtReadFile" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlCtxtReadFile" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (xmlDocPtr)xmlCtxtReadFile(arg1,(char const *)arg2,(char const *)arg3,arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  // free(arg2);
  // free(arg3);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCtxtReadMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCtxtReadMemory.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCtxtReadMemory" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCtxtReadMemory" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlCtxtReadMemory" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlCtxtReadMemory" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else if (node::Buffer::HasInstance(args[4])) {
    arg5 = node::Buffer::Data(Nan::To<v8::Object>(args[4]).ToLocalChecked());
    // printf("data: %s - %i\n", arg5, strlen(arg5));
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlCtxtReadMemory" "', argument " "5"" of type '" "char const *""'");
    }
    
    arg5 = reinterpret_cast< char * >(buf5);
  }ecode6 = SWIG_AsVal_int(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xmlCtxtReadMemory" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);result = (xmlDocPtr)xmlCtxtReadMemory(arg1,(char const *)arg2,arg3,(char const *)arg4,(char const *)arg5,arg6);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  // free(arg2);
  
  // free(arg4);
  // free(arg5);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCtxtReadFd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCtxtReadFd.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCtxtReadFd" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlCtxtReadFd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlCtxtReadFd" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlCtxtReadFd" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlCtxtReadFd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);result = (xmlDocPtr)xmlCtxtReadFd(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  // free(arg3);
  // free(arg4);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCtxtReadIO(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlInputReadCallback arg2 = (xmlInputReadCallback) 0 ;
  xmlInputCloseCallback arg3 = (xmlInputCloseCallback) 0 ;
  void *arg4 = (void *) 0 ;
  char *arg5 = (char *) 0 ;
  char *arg6 = (char *) 0 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  size_t size6 = 0 ;
  int alloc6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 7 || args.Length() > 7) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCtxtReadIO.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCtxtReadIO" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_char_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlCtxtReadIO" "', argument " "2"" of type '" "xmlInputReadCallback""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[2], (void**)(&arg3), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlCtxtReadIO" "', argument " "3"" of type '" "xmlInputCloseCallback""'"); 
      }
    }
  }
  arg4 = getSwigCObjectPtr(args[3]);if (args[4]->IsNull()) {
    arg5 = NULL;
  } else if (node::Buffer::HasInstance(args[4])) {
    arg5 = node::Buffer::Data(Nan::To<v8::Object>(args[4]).ToLocalChecked());
    // printf("data: %s - %i\n", arg5, strlen(arg5));
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlCtxtReadIO" "', argument " "5"" of type '" "char const *""'");
    }
    
    arg5 = reinterpret_cast< char * >(buf5);
  }if (args[5]->IsNull()) {
    arg6 = NULL;
  } else if (node::Buffer::HasInstance(args[5])) {
    arg6 = node::Buffer::Data(Nan::To<v8::Object>(args[5]).ToLocalChecked());
    // printf("data: %s - %i\n", arg6, strlen(arg6));
  } else {
    res6 = SWIG_AsCharPtrAndSize(args[5], &buf6, &size6, &alloc6);
    
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlCtxtReadIO" "', argument " "6"" of type '" "char const *""'");
    }
    
    arg6 = reinterpret_cast< char * >(buf6);
  }ecode7 = SWIG_AsVal_int(args[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "xmlCtxtReadIO" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);result = (xmlDocPtr)xmlCtxtReadIO(arg1,arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,arg7);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  
  
  // free(arg5);
  // free(arg6);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_WITH_THREAD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_THREAD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_TREE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_TREE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_OUTPUT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_OUTPUT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_PUSH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_PUSH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_READER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_READER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_PATTERN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_PATTERN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_WRITER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_WRITER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_SAX1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_SAX1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_FTP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_FTP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_HTTP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_HTTP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_VALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_VALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_HTML_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_HTML));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_LEGACY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_LEGACY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_C14N_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_C14N));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_CATALOG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_CATALOG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_XPATH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_XPATH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_XPTR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_XPTR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_XINCLUDE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_XINCLUDE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_ICONV_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_ICONV));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_ISO8859X_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_ISO8859X));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_UNICODE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_UNICODE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_REGEXP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_REGEXP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_AUTOMATA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_AUTOMATA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_EXPR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_EXPR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_SCHEMAS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_SCHEMAS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_SCHEMATRON_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_SCHEMATRON));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_MODULES_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_MODULES));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_DEBUG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_DEBUG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_DEBUG_MEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_DEBUG_MEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_DEBUG_RUN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_DEBUG_RUN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_ZLIB_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_ZLIB));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_ICU_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_ICU));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_LZMA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_LZMA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_WITH_NONE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_WITH_NONE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlHasFeature(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlFeature arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHasFeature.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlHasFeature" "', argument " "1"" of type '" "xmlFeature""'");
  } 
  arg1 = static_cast< xmlFeature >(val1);result = (int)xmlHasFeature(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XPATH_EXPRESSION_OK_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_EXPRESSION_OK));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_NUMBER_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_NUMBER_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_UNFINISHED_LITERAL_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_UNFINISHED_LITERAL_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_START_LITERAL_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_START_LITERAL_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_VARIABLE_REF_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_VARIABLE_REF_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_UNDEF_VARIABLE_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_UNDEF_VARIABLE_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_INVALID_PREDICATE_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_INVALID_PREDICATE_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_EXPR_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_EXPR_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_UNCLOSED_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_UNCLOSED_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_UNKNOWN_FUNC_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_UNKNOWN_FUNC_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_INVALID_OPERAND_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_INVALID_OPERAND));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_INVALID_TYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_INVALID_TYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_INVALID_ARITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_INVALID_ARITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_INVALID_CTXT_SIZE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_INVALID_CTXT_SIZE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_INVALID_CTXT_POSITION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_INVALID_CTXT_POSITION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_MEMORY_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_MEMORY_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPTR_SYNTAX_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPTR_SYNTAX_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPTR_RESOURCE_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPTR_RESOURCE_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPTR_SUB_RESOURCE_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPTR_SUB_RESOURCE_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_UNDEF_PREFIX_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_UNDEF_PREFIX_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_ENCODING_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_ENCODING_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_INVALID_CHAR_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_INVALID_CHAR_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_INVALID_CTXT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_INVALID_CTXT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_STACK_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_STACK_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_FORBID_VARIABLE_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_FORBID_VARIABLE_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_OP_LIMIT_EXCEEDED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_OP_LIMIT_EXCEEDED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_RECURSION_LIMIT_EXCEEDED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_RECURSION_LIMIT_EXCEEDED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNodeSet_nodeNr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNodeSet *arg1 = (_xmlNodeSet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlNodeSet_nodeNr_set" "', argument " "1"" of type '" "_xmlNodeSet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlNodeSet * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlNodeSet_nodeNr_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nodeNr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNodeSet_nodeNr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNodeSet *arg1 = (_xmlNodeSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlNodeSet_nodeNr_get" "', argument " "1"" of type '" "_xmlNodeSet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlNodeSet * >(argp1);result = (int) ((arg1)->nodeNr);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNodeSet_nodeMax_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNodeSet *arg1 = (_xmlNodeSet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlNodeSet_nodeMax_set" "', argument " "1"" of type '" "_xmlNodeSet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlNodeSet * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlNodeSet_nodeMax_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nodeMax = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNodeSet_nodeMax_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNodeSet *arg1 = (_xmlNodeSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlNodeSet_nodeMax_get" "', argument " "1"" of type '" "_xmlNodeSet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlNodeSet * >(argp1);result = (int) ((arg1)->nodeMax);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlNodeSet_nodeTab_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlNodeSet *arg1 = (_xmlNodeSet *) 0 ;
  xmlNodePtr *arg2 = (xmlNodePtr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlNodeSet_nodeTab_set" "', argument " "1"" of type '" "_xmlNodeSet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlNodeSet * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_p__xmlNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlNodeSet_nodeTab_set" "', argument " "2"" of type '" "xmlNodePtr *""'"); 
  }
  arg2 = reinterpret_cast< xmlNodePtr * >(argp2);if (arg1) (arg1)->nodeTab = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlNodeSet_nodeTab_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlNodeSet *arg1 = (_xmlNodeSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlNodeSet_nodeTab_get" "', argument " "1"" of type '" "_xmlNodeSet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlNodeSet * >(argp1);result = (xmlNodePtr *) ((arg1)->nodeTab);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__xmlNode, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlNodeSet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlNodeSet *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlNodeSet.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlNodeSet.");
  result = (_xmlNodeSet *)new _xmlNodeSet();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlNodeSet, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlNodeSet(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlNodeSet * arg1 = (_xmlNodeSet *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue exports_XPATH_UNDEFINED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_UNDEFINED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_NODESET_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_NODESET));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_BOOLEAN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_BOOLEAN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_NUMBER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_NUMBER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_STRING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_STRING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_USERS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_USERS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_XSLT_TREE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_XSLT_TREE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_POINT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(5));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_RANGE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(6));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XPATH_LOCATIONSET_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(7));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathObject_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  xmlXPathObjectType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_type_set" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathObject_type_set" "', argument " "2"" of type '" "xmlXPathObjectType""'");
  } 
  arg2 = static_cast< xmlXPathObjectType >(val2);if (arg1) (arg1)->type = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathObject_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathObjectType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_type_get" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);result = (xmlXPathObjectType) ((arg1)->type);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathObject_nodesetval_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  xmlNodeSetPtr arg2 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_nodesetval_set" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlNodeSet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathObject_nodesetval_set" "', argument " "2"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlNodeSetPtr >(argp2);if (arg1) (arg1)->nodesetval = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathObject_nodesetval_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodeSetPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_nodesetval_get" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);result = (xmlNodeSetPtr) ((arg1)->nodesetval);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && index < result->nodeNr; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result->nodeTab[index]), SWIGTYPE_p__xmlNode, 0 |  0 ));
      xmlNode* node = ((xmlNode*) result->nodeTab[index]);
      SWIGV8_AppendOutput(jsresult, createWrap(node, xmlNodeGetSwigPtrInfo(node)));
    }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathObject_boolval_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_boolval_set" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathObject_boolval_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->boolval = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathObject_boolval_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_boolval_get" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);result = (int) ((arg1)->boolval);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathObject_floatval_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_floatval_set" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);ecode2 = SWIG_AsVal_double(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathObject_floatval_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);if (arg1) (arg1)->floatval = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathObject_floatval_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_floatval_get" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);result = (double) ((arg1)->floatval);
  jsresult = SWIG_From_double(static_cast< double >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathObject_stringval_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_stringval_set" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathObject_stringval_set" "', argument " "2"" of type '" "xmlChar *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->stringval = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathObject_stringval_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_stringval_get" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);result = (xmlChar *) ((arg1)->stringval);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathObject_user_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_user_set" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->user = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathObject_user_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_user_get" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);result = (void *) ((arg1)->user);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathObject_index_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_index_set" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathObject_index_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->index = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathObject_index_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_index_get" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);result = (int) ((arg1)->index);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathObject_user2_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_user2_set" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->user2 = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathObject_user2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_user2_get" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);result = (void *) ((arg1)->user2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathObject_index2_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_index2_set" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathObject_index2_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->index2 = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathObject_index2_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathObject *arg1 = (_xmlXPathObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathObject_index2_get" "', argument " "1"" of type '" "_xmlXPathObject *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathObject * >(argp1);result = (int) ((arg1)->index2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlXPathObject(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlXPathObject *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlXPathObject.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlXPathObject.");
  result = (_xmlXPathObject *)new _xmlXPathObject();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlXPathObject, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlXPathObject(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlXPathObject * arg1 = (_xmlXPathObject *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlXPathType_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathType *arg1 = (_xmlXPathType *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathType_name_set" "', argument " "1"" of type '" "_xmlXPathType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathType * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathType_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->name = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathType_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathType *arg1 = (_xmlXPathType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathType_name_get" "', argument " "1"" of type '" "_xmlXPathType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathType * >(argp1);result = (xmlChar *) ((arg1)->name);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathType_func_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathType *arg1 = (_xmlXPathType *) 0 ;
  xmlXPathConvertFunc arg2 = (xmlXPathConvertFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathType_func_set" "', argument " "1"" of type '" "_xmlXPathType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathType * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p__xmlXPathObject_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlXPathType_func_set" "', argument " "2"" of type '" "xmlXPathConvertFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->func = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathType_func_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathType *arg1 = (_xmlXPathType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathConvertFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathType_func_get" "', argument " "1"" of type '" "_xmlXPathType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathType * >(argp1);result = (xmlXPathConvertFunc) ((arg1)->func);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p__xmlXPathObject_int__int);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlXPathType(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlXPathType *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlXPathType.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlXPathType.");
  result = (_xmlXPathType *)new _xmlXPathType();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlXPathType, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlXPathType(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlXPathType * arg1 = (_xmlXPathType *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlXPathVariable_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathVariable *arg1 = (_xmlXPathVariable *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathVariable_name_set" "', argument " "1"" of type '" "_xmlXPathVariable *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathVariable * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathVariable_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->name = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathVariable_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathVariable *arg1 = (_xmlXPathVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathVariable_name_get" "', argument " "1"" of type '" "_xmlXPathVariable *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathVariable * >(argp1);result = (xmlChar *) ((arg1)->name);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathVariable_value_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathVariable *arg1 = (_xmlXPathVariable *) 0 ;
  xmlXPathObjectPtr arg2 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathVariable_value_set" "', argument " "1"" of type '" "_xmlXPathVariable *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathVariable * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlXPathObject, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathVariable_value_set" "', argument " "2"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathObjectPtr >(argp2);if (arg1) (arg1)->value = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathVariable_value_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathVariable *arg1 = (_xmlXPathVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathObjectPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathVariable_value_get" "', argument " "1"" of type '" "_xmlXPathVariable *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathVariable * >(argp1);result = (xmlXPathObjectPtr) ((arg1)->value);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlXPathVariable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlXPathVariable *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlXPathVariable.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlXPathVariable.");
  result = (_xmlXPathVariable *)new _xmlXPathVariable();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlXPathVariable, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlXPathVariable(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlXPathVariable * arg1 = (_xmlXPathVariable *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlXPathFunct_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathFunct *arg1 = (_xmlXPathFunct *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathFunct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathFunct_name_set" "', argument " "1"" of type '" "_xmlXPathFunct *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathFunct * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathFunct_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->name = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathFunct_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathFunct *arg1 = (_xmlXPathFunct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathFunct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathFunct_name_get" "', argument " "1"" of type '" "_xmlXPathFunct *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathFunct * >(argp1);result = (xmlChar *) ((arg1)->name);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathFunct_func_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathFunct *arg1 = (_xmlXPathFunct *) 0 ;
  xmlXPathEvalFunc arg2 = (xmlXPathEvalFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathFunct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathFunct_func_set" "', argument " "1"" of type '" "_xmlXPathFunct *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathFunct * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p__xmlXPathParserContext_int__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlXPathFunct_func_set" "', argument " "2"" of type '" "xmlXPathEvalFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->func = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathFunct_func_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathFunct *arg1 = (_xmlXPathFunct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathEvalFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathFunct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathFunct_func_get" "', argument " "1"" of type '" "_xmlXPathFunct *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathFunct * >(argp1);result = (xmlXPathEvalFunc) ((arg1)->func);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p__xmlXPathParserContext_int__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlXPathFunct(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlXPathFunct *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlXPathFunct.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlXPathFunct.");
  result = (_xmlXPathFunct *)new _xmlXPathFunct();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlXPathFunct, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlXPathFunct(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlXPathFunct * arg1 = (_xmlXPathFunct *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlXPathAxis_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathAxis *arg1 = (_xmlXPathAxis *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathAxis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathAxis_name_set" "', argument " "1"" of type '" "_xmlXPathAxis *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathAxis * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathAxis_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->name = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathAxis_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathAxis *arg1 = (_xmlXPathAxis *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathAxis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathAxis_name_get" "', argument " "1"" of type '" "_xmlXPathAxis *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathAxis * >(argp1);result = (xmlChar *) ((arg1)->name);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathAxis_func_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathAxis *arg1 = (_xmlXPathAxis *) 0 ;
  xmlXPathAxisFunc arg2 = (xmlXPathAxisFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathAxis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathAxis_func_set" "', argument " "1"" of type '" "_xmlXPathAxis *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathAxis * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_xmlXPathParserContextPtr_xmlXPathObjectPtr__p__xmlXPathObject);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlXPathAxis_func_set" "', argument " "2"" of type '" "xmlXPathAxisFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->func = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathAxis_func_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathAxis *arg1 = (_xmlXPathAxis *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathAxisFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathAxis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathAxis_func_get" "', argument " "1"" of type '" "_xmlXPathAxis *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathAxis * >(argp1);result = (xmlXPathAxisFunc) ((arg1)->func);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_xmlXPathParserContextPtr_xmlXPathObjectPtr__p__xmlXPathObject);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlXPathAxis(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlXPathAxis *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlXPathAxis.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlXPathAxis.");
  result = (_xmlXPathAxis *)new _xmlXPathAxis();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlXPathAxis, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlXPathAxis(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlXPathAxis * arg1 = (_xmlXPathAxis *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue exports_XML_XPATH_CHECKNS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >((1 << 0)));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_XPATH_NOVAR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >((1 << 1)));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_doc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_doc_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlXPathContext_doc_set', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;if (arg1) (arg1)->doc = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_doc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlDocPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_doc_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlDocPtr) ((arg1)->doc);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_node_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_node_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlXPathContext_node_set', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (arg1) (arg1)->node = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_node_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_node_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlNodePtr) ((arg1)->node);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_nb_variables_unused_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_nb_variables_unused_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathContext_nb_variables_unused_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nb_variables_unused = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_nb_variables_unused_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_nb_variables_unused_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (int) ((arg1)->nb_variables_unused);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_max_variables_unused_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_max_variables_unused_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathContext_max_variables_unused_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->max_variables_unused = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_max_variables_unused_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_max_variables_unused_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (int) ((arg1)->max_variables_unused);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_varHash_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlHashTablePtr arg2 = (xmlHashTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_varHash_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlHashTable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathContext_varHash_set" "', argument " "2"" of type '" "xmlHashTablePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlHashTablePtr >(argp2);if (arg1) (arg1)->varHash = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_varHash_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlHashTablePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_varHash_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlHashTablePtr) ((arg1)->varHash);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_nb_types_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_nb_types_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathContext_nb_types_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nb_types = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_nb_types_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_nb_types_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (int) ((arg1)->nb_types);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_max_types_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_max_types_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathContext_max_types_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->max_types = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_max_types_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_max_types_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (int) ((arg1)->max_types);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_types_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlXPathTypePtr arg2 = (xmlXPathTypePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_types_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlXPathType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathContext_types_set" "', argument " "2"" of type '" "xmlXPathTypePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathTypePtr >(argp2);if (arg1) (arg1)->types = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_types_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathTypePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_types_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlXPathTypePtr) ((arg1)->types);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathType, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_nb_funcs_unused_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_nb_funcs_unused_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathContext_nb_funcs_unused_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nb_funcs_unused = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_nb_funcs_unused_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_nb_funcs_unused_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (int) ((arg1)->nb_funcs_unused);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_max_funcs_unused_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_max_funcs_unused_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathContext_max_funcs_unused_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->max_funcs_unused = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_max_funcs_unused_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_max_funcs_unused_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (int) ((arg1)->max_funcs_unused);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_funcHash_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlHashTablePtr arg2 = (xmlHashTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_funcHash_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlHashTable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathContext_funcHash_set" "', argument " "2"" of type '" "xmlHashTablePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlHashTablePtr >(argp2);if (arg1) (arg1)->funcHash = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_funcHash_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlHashTablePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_funcHash_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlHashTablePtr) ((arg1)->funcHash);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_nb_axis_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_nb_axis_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathContext_nb_axis_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nb_axis = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_nb_axis_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_nb_axis_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (int) ((arg1)->nb_axis);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_max_axis_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_max_axis_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathContext_max_axis_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->max_axis = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_max_axis_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_max_axis_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (int) ((arg1)->max_axis);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_axis_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlXPathAxisPtr arg2 = (xmlXPathAxisPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_axis_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlXPathAxis, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathContext_axis_set" "', argument " "2"" of type '" "xmlXPathAxisPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathAxisPtr >(argp2);if (arg1) (arg1)->axis = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_axis_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathAxisPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_axis_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlXPathAxisPtr) ((arg1)->axis);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathAxis, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_namespaces_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlNsPtr *arg2 = (xmlNsPtr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_namespaces_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathContext_namespaces_set" "', argument " "2"" of type '" "xmlNsPtr *""'"); 
  }
  arg2 = reinterpret_cast< xmlNsPtr * >(argp2);if (arg1) (arg1)->namespaces = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_namespaces_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNsPtr *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_namespaces_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlNsPtr *) ((arg1)->namespaces);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && result[index] != NULL; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result[index]), SWIGTYPE_p__xmlNs, 0 |  0 ));
      SWIGV8_AppendOutput(jsresult, createWrap(((xmlNode*) result[index]), SWIGTYPE_p__xmlNs));
    }
    
    xmlFree(result);
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_nsNr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_nsNr_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathContext_nsNr_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nsNr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_nsNr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_nsNr_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (int) ((arg1)->nsNr);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_user_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_user_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->user = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_user_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_user_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (void *) ((arg1)->user);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_contextSize_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_contextSize_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathContext_contextSize_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->contextSize = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_contextSize_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_contextSize_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (int) ((arg1)->contextSize);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_proximityPosition_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_proximityPosition_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathContext_proximityPosition_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->proximityPosition = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_proximityPosition_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_proximityPosition_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (int) ((arg1)->proximityPosition);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_xptr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_xptr_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathContext_xptr_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->xptr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_xptr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_xptr_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (int) ((arg1)->xptr);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_here_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_here_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlXPathContext_here_set', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (arg1) (arg1)->here = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_here_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_here_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlNodePtr) ((arg1)->here);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_origin_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_origin_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlXPathContext_origin_set', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (arg1) (arg1)->origin = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_origin_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_origin_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlNodePtr) ((arg1)->origin);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_nsHash_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlHashTablePtr arg2 = (xmlHashTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_nsHash_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlHashTable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathContext_nsHash_set" "', argument " "2"" of type '" "xmlHashTablePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlHashTablePtr >(argp2);if (arg1) (arg1)->nsHash = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_nsHash_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlHashTablePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_nsHash_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlHashTablePtr) ((arg1)->nsHash);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_varLookupFunc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlXPathVariableLookupFunc arg2 = (xmlXPathVariableLookupFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_varLookupFunc_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlXPathObject);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlXPathContext_varLookupFunc_set" "', argument " "2"" of type '" "xmlXPathVariableLookupFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->varLookupFunc = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_varLookupFunc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathVariableLookupFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_varLookupFunc_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlXPathVariableLookupFunc) ((arg1)->varLookupFunc);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlXPathObject);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_varLookupData_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_varLookupData_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->varLookupData = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_varLookupData_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_varLookupData_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (void *) ((arg1)->varLookupData);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_extra_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_extra_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->extra = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_extra_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_extra_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (void *) ((arg1)->extra);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext__function_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext__function_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathContext__function_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->function = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext__function_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext__function_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlChar *) ((arg1)->function);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_functionURI_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_functionURI_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathContext_functionURI_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->functionURI = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_functionURI_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_functionURI_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlChar *) ((arg1)->functionURI);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_funcLookupFunc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlXPathFuncLookupFunc arg2 = (xmlXPathFuncLookupFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_funcLookupFunc_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__p_f_p__xmlXPathParserContext_int__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlXPathContext_funcLookupFunc_set" "', argument " "2"" of type '" "xmlXPathFuncLookupFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->funcLookupFunc = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_funcLookupFunc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathFuncLookupFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_funcLookupFunc_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlXPathFuncLookupFunc) ((arg1)->funcLookupFunc);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__p_f_p__xmlXPathParserContext_int__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_funcLookupData_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_funcLookupData_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->funcLookupData = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_funcLookupData_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_funcLookupData_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (void *) ((arg1)->funcLookupData);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_tmpNsList_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlNsPtr *arg2 = (xmlNsPtr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_tmpNsList_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathContext_tmpNsList_set" "', argument " "2"" of type '" "xmlNsPtr *""'"); 
  }
  arg2 = reinterpret_cast< xmlNsPtr * >(argp2);if (arg1) (arg1)->tmpNsList = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_tmpNsList_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNsPtr *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_tmpNsList_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlNsPtr *) ((arg1)->tmpNsList);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && result[index] != NULL; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result[index]), SWIGTYPE_p__xmlNs, 0 |  0 ));
      SWIGV8_AppendOutput(jsresult, createWrap(((xmlNode*) result[index]), SWIGTYPE_p__xmlNs));
    }
    
    xmlFree(result);
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_tmpNsNr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_tmpNsNr_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathContext_tmpNsNr_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->tmpNsNr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_tmpNsNr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_tmpNsNr_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (int) ((arg1)->tmpNsNr);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_userData_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_userData_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->userData = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_userData_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_userData_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (void *) ((arg1)->userData);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_error_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlStructuredErrorFunc arg2 = (xmlStructuredErrorFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_error_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const___xmlError__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xmlXPathContext_error_set" "', argument " "2"" of type '" "xmlStructuredErrorFunc""'"); 
      }
    }
  }
  if (arg1) (arg1)->error = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_error_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlStructuredErrorFunc result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_error_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlStructuredErrorFunc) ((arg1)->error);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const___xmlError__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_lastError_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlError *arg2 = (xmlError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_lastError_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathContext_lastError_set" "', argument " "2"" of type '" "xmlError *""'"); 
  }
  arg2 = reinterpret_cast< xmlError * >(argp2);if (arg1) (arg1)->lastError = *arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_lastError_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlError *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_lastError_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlError *)& ((arg1)->lastError);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlError, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_debugNode_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_debugNode_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlXPathContext_debugNode_set', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (arg1) (arg1)->debugNode = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_debugNode_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_debugNode_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlNodePtr) ((arg1)->debugNode);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_dict_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  xmlDictPtr arg2 = (xmlDictPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_dict_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlDict, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathContext_dict_set" "', argument " "2"" of type '" "xmlDictPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlDictPtr >(argp2);if (arg1) (arg1)->dict = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_dict_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlDictPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_dict_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (xmlDictPtr) ((arg1)->dict);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlDict, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_flags_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_flags_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathContext_flags_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->flags = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_flags_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_flags_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (int) ((arg1)->flags);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_cache_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_cache_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->cache = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_cache_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_cache_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (void *) ((arg1)->cache);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_opLimit_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_opLimit_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_long(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathContext_opLimit_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);if (arg1) (arg1)->opLimit = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_opLimit_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_opLimit_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (unsigned long) ((arg1)->opLimit);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_opCount_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_opCount_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_long(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathContext_opCount_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);if (arg1) (arg1)->opCount = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_opCount_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_opCount_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (unsigned long) ((arg1)->opCount);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathContext_depth_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_depth_set" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathContext_depth_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->depth = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathContext_depth_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathContext *arg1 = (_xmlXPathContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathContext_depth_get" "', argument " "1"" of type '" "_xmlXPathContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathContext * >(argp1);result = (int) ((arg1)->depth);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlXPathContext(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlXPathContext *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlXPathContext.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlXPathContext.");
  result = (_xmlXPathContext *)new _xmlXPathContext();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlXPathContext, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlXPathContext(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlXPathContext * arg1 = (_xmlXPathContext *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlXPathParserContext_cur_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_cur_set" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathParserContext_cur_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->cur = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathParserContext_cur_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_cur_get" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);result = (xmlChar *) ((arg1)->cur);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathParserContext_base_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_base_set" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathParserContext_base_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->base = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathParserContext_base_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_base_get" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);result = (xmlChar *) ((arg1)->base);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathParserContext_error_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_error_set" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathParserContext_error_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->error = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathParserContext_error_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_error_get" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);result = (int) ((arg1)->error);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathParserContext_context_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  xmlXPathContextPtr arg2 = (xmlXPathContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_context_set" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlXPathContext, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathParserContext_context_set" "', argument " "2"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathContextPtr >(argp2);if (arg1) (arg1)->context = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathParserContext_context_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathContextPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_context_get" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);result = (xmlXPathContextPtr) ((arg1)->context);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathParserContext_value_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  xmlXPathObjectPtr arg2 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_value_set" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlXPathObject, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathParserContext_value_set" "', argument " "2"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathObjectPtr >(argp2);if (arg1) (arg1)->value = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathParserContext_value_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathObjectPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_value_get" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);result = (xmlXPathObjectPtr) ((arg1)->value);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathParserContext_valueNr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_valueNr_set" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathParserContext_valueNr_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->valueNr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathParserContext_valueNr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_valueNr_get" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);result = (int) ((arg1)->valueNr);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathParserContext_valueMax_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_valueMax_set" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathParserContext_valueMax_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->valueMax = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathParserContext_valueMax_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_valueMax_get" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);result = (int) ((arg1)->valueMax);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathParserContext_valueTab_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  xmlXPathObjectPtr *arg2 = (xmlXPathObjectPtr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_valueTab_set" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathParserContext_valueTab_set" "', argument " "2"" of type '" "xmlXPathObjectPtr *""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathObjectPtr * >(argp2);if (arg1) (arg1)->valueTab = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathParserContext_valueTab_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathObjectPtr *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_valueTab_get" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);result = (xmlXPathObjectPtr *) ((arg1)->valueTab);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__xmlXPathObject, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathParserContext_comp_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  xmlXPathCompExprPtr arg2 = (xmlXPathCompExprPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_comp_set" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlXPathCompExpr, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlXPathParserContext_comp_set" "', argument " "2"" of type '" "xmlXPathCompExprPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathCompExprPtr >(argp2);if (arg1) (arg1)->comp = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathParserContext_comp_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathCompExprPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_comp_get" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);result = (xmlXPathCompExprPtr) ((arg1)->comp);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathCompExpr, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathParserContext_xptr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_xptr_set" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathParserContext_xptr_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->xptr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathParserContext_xptr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_xptr_get" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);result = (int) ((arg1)->xptr);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathParserContext_ancestor_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_ancestor_set" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlXPathParserContext_ancestor_set', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (arg1) (arg1)->ancestor = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathParserContext_ancestor_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_ancestor_get" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);result = (xmlNodePtr) ((arg1)->ancestor);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlXPathParserContext_valueFrame_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_valueFrame_set" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlXPathParserContext_valueFrame_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->valueFrame = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlXPathParserContext_valueFrame_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlXPathParserContext *arg1 = (_xmlXPathParserContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlXPathParserContext_valueFrame_get" "', argument " "1"" of type '" "_xmlXPathParserContext *""'"); 
  }
  arg1 = reinterpret_cast< _xmlXPathParserContext * >(argp1);result = (int) ((arg1)->valueFrame);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlXPathParserContext(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlXPathParserContext *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlXPathParserContext.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlXPathParserContext.");
  result = (_xmlXPathParserContext *)new _xmlXPathParserContext();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlXPathParserContext, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlXPathParserContext(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlXPathParserContext * arg1 = (_xmlXPathParserContext *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap_xmlXPathNAN_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  
  ecode1 = SWIG_AsVal_double(value, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlXPathNAN_set" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);xmlXPathNAN = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlXPathNAN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  double result;
  
  result = (double)xmlXPathNAN;
  jsresult = SWIG_From_double(static_cast< double >(result));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap_xmlXPathPINF_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  
  ecode1 = SWIG_AsVal_double(value, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlXPathPINF_set" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);xmlXPathPINF = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlXPathPINF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  double result;
  
  result = (double)xmlXPathPINF;
  jsresult = SWIG_From_double(static_cast< double >(result));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap_xmlXPathNINF_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  
  ecode1 = SWIG_AsVal_double(value, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlXPathNINF_set" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);xmlXPathNINF = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlXPathNINF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  double result;
  
  result = (double)xmlXPathNINF;
  jsresult = SWIG_From_double(static_cast< double >(result));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlXPathFreeObject(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathObjectPtr arg1 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathFreeObject.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathFreeObject" "', argument " "1"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathObjectPtr >(argp1);xmlXPathFreeObject(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNodeSetCreate(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlNodeSetPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNodeSetCreate.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXPathNodeSetCreate', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);result = (xmlNodeSetPtr)xmlXPathNodeSetCreate(arg1);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && index < result->nodeNr; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result->nodeTab[index]), SWIGTYPE_p__xmlNode, 0 |  0 ));
      xmlNode* node = ((xmlNode*) result->nodeTab[index]);
      SWIGV8_AppendOutput(jsresult, createWrap(node, xmlNodeGetSwigPtrInfo(node)));
    }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathFreeNodeSetList(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathObjectPtr arg1 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathFreeNodeSetList.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathFreeNodeSetList" "', argument " "1"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathObjectPtr >(argp1);xmlXPathFreeNodeSetList(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathFreeNodeSet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathFreeNodeSet.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathFreeNodeSet" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);xmlXPathFreeNodeSet(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathObjectCopy(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathObjectPtr arg1 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathObjectCopy.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathObjectCopy" "', argument " "1"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathObjectPtr >(argp1);result = (xmlXPathObjectPtr)xmlXPathObjectCopy(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCmpNodes(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCmpNodes.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXPathCmpNodes', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathCmpNodes', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (int)xmlXPathCmpNodes(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCastNumberToBoolean(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCastNumberToBoolean.");
  
  ecode1 = SWIG_AsVal_double(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlXPathCastNumberToBoolean" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);result = (int)xmlXPathCastNumberToBoolean(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCastStringToBoolean(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCastStringToBoolean.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathCastStringToBoolean" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (int)xmlXPathCastStringToBoolean((unsigned char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCastNodeSetToBoolean(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCastNodeSetToBoolean.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathCastNodeSetToBoolean" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);result = (int)xmlXPathCastNodeSetToBoolean(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCastToBoolean(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathObjectPtr arg1 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCastToBoolean.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathCastToBoolean" "', argument " "1"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathObjectPtr >(argp1);result = (int)xmlXPathCastToBoolean(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCastBooleanToNumber(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  double result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCastBooleanToNumber.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlXPathCastBooleanToNumber" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (double)xmlXPathCastBooleanToNumber(arg1);
  jsresult = SWIG_From_double(static_cast< double >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCastStringToNumber(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  double result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCastStringToNumber.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathCastStringToNumber" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (double)xmlXPathCastStringToNumber((unsigned char const *)arg1);
  jsresult = SWIG_From_double(static_cast< double >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCastNodeToNumber(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  double result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCastNodeToNumber.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXPathCastNodeToNumber', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);result = (double)xmlXPathCastNodeToNumber(arg1);
  jsresult = SWIG_From_double(static_cast< double >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCastNodeSetToNumber(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCastNodeSetToNumber.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathCastNodeSetToNumber" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);result = (double)xmlXPathCastNodeSetToNumber(arg1);
  jsresult = SWIG_From_double(static_cast< double >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCastToNumber(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathObjectPtr arg1 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCastToNumber.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathCastToNumber" "', argument " "1"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathObjectPtr >(argp1);result = (double)xmlXPathCastToNumber(arg1);
  jsresult = SWIG_From_double(static_cast< double >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCastBooleanToString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCastBooleanToString.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlXPathCastBooleanToString" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (xmlChar *)xmlXPathCastBooleanToString(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCastNumberToString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCastNumberToString.");
  
  ecode1 = SWIG_AsVal_double(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlXPathCastNumberToString" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);result = (xmlChar *)xmlXPathCastNumberToString(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCastNodeToString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCastNodeToString.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXPathCastNodeToString', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);result = (xmlChar *)xmlXPathCastNodeToString(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCastNodeSetToString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCastNodeSetToString.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathCastNodeSetToString" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);result = (xmlChar *)xmlXPathCastNodeSetToString(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCastToString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathObjectPtr arg1 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCastToString.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathCastToString" "', argument " "1"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathObjectPtr >(argp1);result = (xmlChar *)xmlXPathCastToString(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathConvertBoolean(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathObjectPtr arg1 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathConvertBoolean.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathConvertBoolean" "', argument " "1"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathObjectPtr >(argp1);result = (xmlXPathObjectPtr)xmlXPathConvertBoolean(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathConvertNumber(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathObjectPtr arg1 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathConvertNumber.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathConvertNumber" "', argument " "1"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathObjectPtr >(argp1);result = (xmlXPathObjectPtr)xmlXPathConvertNumber(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathConvertString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathObjectPtr arg1 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathConvertString.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathConvertString" "', argument " "1"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathObjectPtr >(argp1);result = (xmlXPathObjectPtr)xmlXPathConvertString(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNewContext(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlXPathContextPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNewContext.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXPathNewContext', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;result = (xmlXPathContextPtr)xmlXPathNewContext(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathFreeContext(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathFreeContext.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathFreeContext" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);xmlXPathFreeContext(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathSetErrorHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  xmlStructuredErrorFunc arg2 = (xmlStructuredErrorFunc) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathSetErrorHandler.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathSetErrorHandler" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const___xmlError__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlXPathSetErrorHandler" "', argument " "2"" of type '" "xmlStructuredErrorFunc""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);xmlXPathSetErrorHandler(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathContextSetCache(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathContextSetCache.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathContextSetCache" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathContextSetCache" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlXPathContextSetCache" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlXPathContextSetCache" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (int)xmlXPathContextSetCache(arg1,arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathOrderDocElems(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  int res1 ;
  void *arg10 ;
  long result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathOrderDocElems.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXPathOrderDocElems', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;result = (long)xmlXPathOrderDocElems(arg1);
  jsresult = SWIG_From_long(static_cast< long >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathSetContextNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlXPathContextPtr arg2 = (xmlXPathContextPtr) 0 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathSetContextNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXPathSetContextNode', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathSetContextNode" "', argument " "2"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathContextPtr >(argp2);result = (int)xmlXPathSetContextNode(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNodeEval(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlXPathContextPtr arg3 = (xmlXPathContextPtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNodeEval.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXPathNodeEval', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathNodeEval" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlXPathNodeEval" "', argument " "3"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg3 = reinterpret_cast< xmlXPathContextPtr >(argp3);result = (xmlXPathObjectPtr)xmlXPathNodeEval(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathEval(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlXPathContextPtr arg2 = (xmlXPathContextPtr) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathEval.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathEval" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathEval" "', argument " "2"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathContextPtr >(argp2);result = (xmlXPathObjectPtr)xmlXPathEval((unsigned char const *)arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathEvalExpression(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlXPathContextPtr arg2 = (xmlXPathContextPtr) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathEvalExpression.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathEvalExpression" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathEvalExpression" "', argument " "2"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathContextPtr >(argp2);result = (xmlXPathObjectPtr)xmlXPathEvalExpression((unsigned char const *)arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathEvalPredicate(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  xmlXPathObjectPtr arg2 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathEvalPredicate.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathEvalPredicate" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathEvalPredicate" "', argument " "2"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathObjectPtr >(argp2);result = (int)xmlXPathEvalPredicate(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCompile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlXPathCompExprPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCompile.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathCompile" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlXPathCompExprPtr)xmlXPathCompile((unsigned char const *)arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathCompExpr, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCtxtCompile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlXPathCompExprPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCtxtCompile.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathCtxtCompile" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathCtxtCompile" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlXPathCompExprPtr)xmlXPathCtxtCompile(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathCompExpr, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCompiledEval(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathCompExprPtr arg1 = (xmlXPathCompExprPtr) 0 ;
  xmlXPathContextPtr arg2 = (xmlXPathContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCompiledEval.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathCompExpr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathCompiledEval" "', argument " "1"" of type '" "xmlXPathCompExprPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathCompExprPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathCompiledEval" "', argument " "2"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathContextPtr >(argp2);result = (xmlXPathObjectPtr)xmlXPathCompiledEval(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCompiledEvalToBoolean(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathCompExprPtr arg1 = (xmlXPathCompExprPtr) 0 ;
  xmlXPathContextPtr arg2 = (xmlXPathContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCompiledEvalToBoolean.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathCompExpr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathCompiledEvalToBoolean" "', argument " "1"" of type '" "xmlXPathCompExprPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathCompExprPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathCompiledEvalToBoolean" "', argument " "2"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathContextPtr >(argp2);result = (int)xmlXPathCompiledEvalToBoolean(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathFreeCompExpr(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathCompExprPtr arg1 = (xmlXPathCompExprPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathFreeCompExpr.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathCompExpr, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathFreeCompExpr" "', argument " "1"" of type '" "xmlXPathCompExprPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathCompExprPtr >(argp1);xmlXPathFreeCompExpr(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathInit(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathInit.");
  
  xmlXPathInit();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathIsNaN(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathIsNaN.");
  
  ecode1 = SWIG_AsVal_double(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlXPathIsNaN" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);result = (int)xmlXPathIsNaN(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathIsInf(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathIsInf.");
  
  ecode1 = SWIG_AsVal_double(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlXPathIsInf" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);result = (int)xmlXPathIsInf(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathPopBoolean(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathPopBoolean.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathPopBoolean" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);result = (int)xmlXPathPopBoolean(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathPopNumber(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathPopNumber.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathPopNumber" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);result = (double)xmlXPathPopNumber(arg1);
  jsresult = SWIG_From_double(static_cast< double >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathPopString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathPopString.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathPopString" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);result = (xmlChar *)xmlXPathPopString(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathPopNodeSet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodeSetPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathPopNodeSet.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathPopNodeSet" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);result = (xmlNodeSetPtr)xmlXPathPopNodeSet(arg1);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && index < result->nodeNr; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result->nodeTab[index]), SWIGTYPE_p__xmlNode, 0 |  0 ));
      xmlNode* node = ((xmlNode*) result->nodeTab[index]);
      SWIGV8_AppendOutput(jsresult, createWrap(node, xmlNodeGetSwigPtrInfo(node)));
    }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathPopExternal(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathPopExternal.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathPopExternal" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);result = (void *)xmlXPathPopExternal(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathRegisterVariableLookup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  xmlXPathVariableLookupFunc arg2 = (xmlXPathVariableLookupFunc) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathRegisterVariableLookup.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathRegisterVariableLookup" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlXPathObject);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlXPathRegisterVariableLookup" "', argument " "2"" of type '" "xmlXPathVariableLookupFunc""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);xmlXPathRegisterVariableLookup(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathRegisterFuncLookup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  xmlXPathFuncLookupFunc arg2 = (xmlXPathFuncLookupFunc) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathRegisterFuncLookup.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathRegisterFuncLookup" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__p_f_p__xmlXPathParserContext_int__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlXPathRegisterFuncLookup" "', argument " "2"" of type '" "xmlXPathFuncLookupFunc""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);xmlXPathRegisterFuncLookup(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPatherror(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPatherror.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPatherror" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPatherror" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlXPatherror" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlXPatherror" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);xmlXPatherror(arg1,(char const *)arg2,arg3,arg4);
  jsresult = SWIGV8_UNDEFINED();
  
  // free(arg2);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathErr(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathErr.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathErr" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathErr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathErr(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathDebugDumpObject(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  xmlXPathObjectPtr arg2 = (xmlXPathObjectPtr) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathDebugDumpObject.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathDebugDumpObject" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathDebugDumpObject" "', argument " "2"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathObjectPtr >(argp2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlXPathDebugDumpObject" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);xmlXPathDebugDumpObject(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathDebugDumpCompExpr(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  xmlXPathCompExprPtr arg2 = (xmlXPathCompExprPtr) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathDebugDumpCompExpr.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathDebugDumpCompExpr" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlXPathCompExpr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathDebugDumpCompExpr" "', argument " "2"" of type '" "xmlXPathCompExprPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathCompExprPtr >(argp2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlXPathDebugDumpCompExpr" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);xmlXPathDebugDumpCompExpr(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNodeSetContains(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNodeSetContains.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNodeSetContains" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNodeSetContains', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (int)xmlXPathNodeSetContains(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathDifference(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  xmlNodeSetPtr arg2 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlNodeSetPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathDifference.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathDifference" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathDifference" "', argument " "2"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlNodeSetPtr >(argp2);result = (xmlNodeSetPtr)xmlXPathDifference(arg1,arg2);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && index < result->nodeNr; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result->nodeTab[index]), SWIGTYPE_p__xmlNode, 0 |  0 ));
      xmlNode* node = ((xmlNode*) result->nodeTab[index]);
      SWIGV8_AppendOutput(jsresult, createWrap(node, xmlNodeGetSwigPtrInfo(node)));
    }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathIntersection(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  xmlNodeSetPtr arg2 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlNodeSetPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathIntersection.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathIntersection" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathIntersection" "', argument " "2"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlNodeSetPtr >(argp2);result = (xmlNodeSetPtr)xmlXPathIntersection(arg1,arg2);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && index < result->nodeNr; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result->nodeTab[index]), SWIGTYPE_p__xmlNode, 0 |  0 ));
      xmlNode* node = ((xmlNode*) result->nodeTab[index]);
      SWIGV8_AppendOutput(jsresult, createWrap(node, xmlNodeGetSwigPtrInfo(node)));
    }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathDistinctSorted(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodeSetPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathDistinctSorted.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathDistinctSorted" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);result = (xmlNodeSetPtr)xmlXPathDistinctSorted(arg1);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && index < result->nodeNr; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result->nodeTab[index]), SWIGTYPE_p__xmlNode, 0 |  0 ));
      xmlNode* node = ((xmlNode*) result->nodeTab[index]);
      SWIGV8_AppendOutput(jsresult, createWrap(node, xmlNodeGetSwigPtrInfo(node)));
    }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathDistinct(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodeSetPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathDistinct.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathDistinct" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);result = (xmlNodeSetPtr)xmlXPathDistinct(arg1);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && index < result->nodeNr; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result->nodeTab[index]), SWIGTYPE_p__xmlNode, 0 |  0 ));
      xmlNode* node = ((xmlNode*) result->nodeTab[index]);
      SWIGV8_AppendOutput(jsresult, createWrap(node, xmlNodeGetSwigPtrInfo(node)));
    }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathHasSameNodes(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  xmlNodeSetPtr arg2 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathHasSameNodes.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathHasSameNodes" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathHasSameNodes" "', argument " "2"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlNodeSetPtr >(argp2);result = (int)xmlXPathHasSameNodes(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNodeLeadingSorted(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlNodeSetPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNodeLeadingSorted.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNodeLeadingSorted" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNodeLeadingSorted', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodeSetPtr)xmlXPathNodeLeadingSorted(arg1,arg2);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && index < result->nodeNr; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result->nodeTab[index]), SWIGTYPE_p__xmlNode, 0 |  0 ));
      xmlNode* node = ((xmlNode*) result->nodeTab[index]);
      SWIGV8_AppendOutput(jsresult, createWrap(node, xmlNodeGetSwigPtrInfo(node)));
    }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathLeadingSorted(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  xmlNodeSetPtr arg2 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlNodeSetPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathLeadingSorted.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathLeadingSorted" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathLeadingSorted" "', argument " "2"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlNodeSetPtr >(argp2);result = (xmlNodeSetPtr)xmlXPathLeadingSorted(arg1,arg2);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && index < result->nodeNr; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result->nodeTab[index]), SWIGTYPE_p__xmlNode, 0 |  0 ));
      xmlNode* node = ((xmlNode*) result->nodeTab[index]);
      SWIGV8_AppendOutput(jsresult, createWrap(node, xmlNodeGetSwigPtrInfo(node)));
    }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNodeLeading(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlNodeSetPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNodeLeading.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNodeLeading" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNodeLeading', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodeSetPtr)xmlXPathNodeLeading(arg1,arg2);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && index < result->nodeNr; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result->nodeTab[index]), SWIGTYPE_p__xmlNode, 0 |  0 ));
      xmlNode* node = ((xmlNode*) result->nodeTab[index]);
      SWIGV8_AppendOutput(jsresult, createWrap(node, xmlNodeGetSwigPtrInfo(node)));
    }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathLeading(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  xmlNodeSetPtr arg2 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlNodeSetPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathLeading.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathLeading" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathLeading" "', argument " "2"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlNodeSetPtr >(argp2);result = (xmlNodeSetPtr)xmlXPathLeading(arg1,arg2);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && index < result->nodeNr; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result->nodeTab[index]), SWIGTYPE_p__xmlNode, 0 |  0 ));
      xmlNode* node = ((xmlNode*) result->nodeTab[index]);
      SWIGV8_AppendOutput(jsresult, createWrap(node, xmlNodeGetSwigPtrInfo(node)));
    }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNodeTrailingSorted(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlNodeSetPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNodeTrailingSorted.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNodeTrailingSorted" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNodeTrailingSorted', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodeSetPtr)xmlXPathNodeTrailingSorted(arg1,arg2);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && index < result->nodeNr; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result->nodeTab[index]), SWIGTYPE_p__xmlNode, 0 |  0 ));
      xmlNode* node = ((xmlNode*) result->nodeTab[index]);
      SWIGV8_AppendOutput(jsresult, createWrap(node, xmlNodeGetSwigPtrInfo(node)));
    }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathTrailingSorted(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  xmlNodeSetPtr arg2 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlNodeSetPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathTrailingSorted.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathTrailingSorted" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathTrailingSorted" "', argument " "2"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlNodeSetPtr >(argp2);result = (xmlNodeSetPtr)xmlXPathTrailingSorted(arg1,arg2);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && index < result->nodeNr; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result->nodeTab[index]), SWIGTYPE_p__xmlNode, 0 |  0 ));
      xmlNode* node = ((xmlNode*) result->nodeTab[index]);
      SWIGV8_AppendOutput(jsresult, createWrap(node, xmlNodeGetSwigPtrInfo(node)));
    }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNodeTrailing(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlNodeSetPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNodeTrailing.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNodeTrailing" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNodeTrailing', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodeSetPtr)xmlXPathNodeTrailing(arg1,arg2);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && index < result->nodeNr; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result->nodeTab[index]), SWIGTYPE_p__xmlNode, 0 |  0 ));
      xmlNode* node = ((xmlNode*) result->nodeTab[index]);
      SWIGV8_AppendOutput(jsresult, createWrap(node, xmlNodeGetSwigPtrInfo(node)));
    }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathTrailing(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  xmlNodeSetPtr arg2 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlNodeSetPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathTrailing.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathTrailing" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathTrailing" "', argument " "2"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlNodeSetPtr >(argp2);result = (xmlNodeSetPtr)xmlXPathTrailing(arg1,arg2);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && index < result->nodeNr; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result->nodeTab[index]), SWIGTYPE_p__xmlNode, 0 |  0 ));
      xmlNode* node = ((xmlNode*) result->nodeTab[index]);
      SWIGV8_AppendOutput(jsresult, createWrap(node, xmlNodeGetSwigPtrInfo(node)));
    }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathRegisterNs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathRegisterNs.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathRegisterNs" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathRegisterNs" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlXPathRegisterNs" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (int)xmlXPathRegisterNs(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNsLookup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNsLookup.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNsLookup" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathNsLookup" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlXPathNsLookup(arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathRegisteredNsCleanup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathRegisteredNsCleanup.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathRegisteredNsCleanup" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);xmlXPathRegisteredNsCleanup(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathRegisterFunc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlXPathFunction arg3 = (xmlXPathFunction) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathRegisterFunc.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathRegisterFunc" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathRegisterFunc" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }{
    {
      int res = SWIG_ConvertFunctionPtr(args[2], (void**)(&arg3), SWIGTYPE_p_f_p__xmlXPathParserContext_int__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlXPathRegisterFunc" "', argument " "3"" of type '" "xmlXPathFunction""'"); 
      }
    }
  }
  result = (int)xmlXPathRegisterFunc(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathRegisterFuncNS(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlXPathFunction arg4 = (xmlXPathFunction) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathRegisterFuncNS.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathRegisterFuncNS" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathRegisterFuncNS" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlXPathRegisterFuncNS" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }{
    {
      int res = SWIG_ConvertFunctionPtr(args[3], (void**)(&arg4), SWIGTYPE_p_f_p__xmlXPathParserContext_int__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlXPathRegisterFuncNS" "', argument " "4"" of type '" "xmlXPathFunction""'"); 
      }
    }
  }
  result = (int)xmlXPathRegisterFuncNS(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathRegisterVariable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlXPathObjectPtr arg3 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathRegisterVariable.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathRegisterVariable" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathRegisterVariable" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlXPathRegisterVariable" "', argument " "3"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg3 = reinterpret_cast< xmlXPathObjectPtr >(argp3);result = (int)xmlXPathRegisterVariable(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathRegisterVariableNS(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlXPathObjectPtr arg4 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathRegisterVariableNS.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathRegisterVariableNS" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathRegisterVariableNS" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlXPathRegisterVariableNS" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlXPathRegisterVariableNS" "', argument " "4"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg4 = reinterpret_cast< xmlXPathObjectPtr >(argp4);result = (int)xmlXPathRegisterVariableNS(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathFunctionLookup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlXPathFunction result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathFunctionLookup.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathFunctionLookup" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathFunctionLookup" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlXPathFunction)xmlXPathFunctionLookup(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p__xmlXPathParserContext_int__void);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathFunctionLookupNS(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlXPathFunction result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathFunctionLookupNS.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathFunctionLookupNS" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathFunctionLookupNS" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlXPathFunctionLookupNS" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlXPathFunction)xmlXPathFunctionLookupNS(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p__xmlXPathParserContext_int__void);
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathRegisteredFuncsCleanup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathRegisteredFuncsCleanup.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathRegisteredFuncsCleanup" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);xmlXPathRegisteredFuncsCleanup(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathVariableLookup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathVariableLookup.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathVariableLookup" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathVariableLookup" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlXPathObjectPtr)xmlXPathVariableLookup(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathVariableLookupNS(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathVariableLookupNS.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathVariableLookupNS" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathVariableLookupNS" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlXPathVariableLookupNS" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlXPathObjectPtr)xmlXPathVariableLookupNS(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathRegisteredVariablesCleanup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathRegisteredVariablesCleanup.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathRegisteredVariablesCleanup" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);xmlXPathRegisteredVariablesCleanup(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNewParserContext(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlXPathContextPtr arg2 = (xmlXPathContextPtr) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlXPathParserContextPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNewParserContext.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNewParserContext" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathNewParserContext" "', argument " "2"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathContextPtr >(argp2);result = (xmlXPathParserContextPtr)xmlXPathNewParserContext((unsigned char const *)arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathFreeParserContext(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathFreeParserContext.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathFreeParserContext" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);xmlXPathFreeParserContext(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_valuePop(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_valuePop.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "valuePop" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);result = (xmlXPathObjectPtr)valuePop(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_valuePush(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  xmlXPathObjectPtr arg2 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_valuePush.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "valuePush" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "valuePush" "', argument " "2"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathObjectPtr >(argp2);result = (int)valuePush(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNewString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNewString.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNewString" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlXPathObjectPtr)xmlXPathNewString((unsigned char const *)arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNewCString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNewCString.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNewCString" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (xmlXPathObjectPtr)xmlXPathNewCString((char const *)arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathWrapString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathWrapString.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathWrapString" "', argument " "1"" of type '" "xmlChar *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlXPathObjectPtr)xmlXPathWrapString(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathWrapCString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathWrapCString.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathWrapCString" "', argument " "1"" of type '" "char *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (xmlXPathObjectPtr)xmlXPathWrapCString(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNewFloat(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNewFloat.");
  
  ecode1 = SWIG_AsVal_double(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlXPathNewFloat" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);result = (xmlXPathObjectPtr)xmlXPathNewFloat(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNewBoolean(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNewBoolean.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlXPathNewBoolean" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (xmlXPathObjectPtr)xmlXPathNewBoolean(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNewNodeSet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNewNodeSet.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXPathNewNodeSet', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);result = (xmlXPathObjectPtr)xmlXPathNewNodeSet(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNewValueTree(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNewValueTree.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXPathNewValueTree', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);result = (xmlXPathObjectPtr)xmlXPathNewValueTree(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNodeSetAdd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNodeSetAdd.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNodeSetAdd" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNodeSetAdd', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (int)xmlXPathNodeSetAdd(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNodeSetAddUnique(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNodeSetAddUnique.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNodeSetAddUnique" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNodeSetAddUnique', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (int)xmlXPathNodeSetAddUnique(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNodeSetAddNs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  xmlNsPtr arg3 = (xmlNsPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNodeSetAddNs.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNodeSetAddNs" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNodeSetAddNs', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlXPathNodeSetAddNs', argument 3 of type 'xmlNsPtr'"); 
  }
  arg3 = (xmlNsPtr) arg30;result = (int)xmlXPathNodeSetAddNs(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNodeSetSort(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNodeSetSort.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNodeSetSort" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);xmlXPathNodeSetSort(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathRoot(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathRoot.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathRoot" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);xmlXPathRoot(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathEvalExpr(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathEvalExpr.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathEvalExpr" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);xmlXPathEvalExpr(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathParseName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathParseName.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathParseName" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);result = (xmlChar *)xmlXPathParseName(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathParseNCName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathParseNCName.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathParseNCName" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);result = (xmlChar *)xmlXPathParseNCName(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathStringEvalNumber(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  double result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathStringEvalNumber.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathStringEvalNumber" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (double)xmlXPathStringEvalNumber((unsigned char const *)arg1);
  jsresult = SWIG_From_double(static_cast< double >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathEvaluatePredicateResult(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  xmlXPathObjectPtr arg2 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathEvaluatePredicateResult.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathEvaluatePredicateResult" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathEvaluatePredicateResult" "', argument " "2"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathObjectPtr >(argp2);result = (int)xmlXPathEvaluatePredicateResult(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathRegisterAllFunctions(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathContextPtr arg1 = (xmlXPathContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathRegisterAllFunctions.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathRegisterAllFunctions" "', argument " "1"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathContextPtr >(argp1);xmlXPathRegisterAllFunctions(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNodeSetMerge(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  xmlNodeSetPtr arg2 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlNodeSetPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNodeSetMerge.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNodeSetMerge" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPathNodeSetMerge" "', argument " "2"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlNodeSetPtr >(argp2);result = (xmlNodeSetPtr)xmlXPathNodeSetMerge(arg1,arg2);
  {
    jsresult = SWIGV8_ARRAY_NEW(0);
    
    for (int index = 0; result != NULL && index < result->nodeNr; index++) {
      // SWIGV8_AppendOutput(jsresult, SWIG_NewPointerObj(SWIG_as_voidptr(result->nodeTab[index]), SWIGTYPE_p__xmlNode, 0 |  0 ));
      xmlNode* node = ((xmlNode*) result->nodeTab[index]);
      SWIGV8_AppendOutput(jsresult, createWrap(node, xmlNodeGetSwigPtrInfo(node)));
    }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNodeSetDel(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNodeSetDel.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNodeSetDel" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNodeSetDel', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);xmlXPathNodeSetDel(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNodeSetRemove(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNodeSetRemove.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNodeSetRemove" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathNodeSetRemove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathNodeSetRemove(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNewNodeSetList(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNewNodeSetList.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNewNodeSetList" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);result = (xmlXPathObjectPtr)xmlXPathNewNodeSetList(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathWrapNodeSet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathWrapNodeSet.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathWrapNodeSet" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);result = (xmlXPathObjectPtr)xmlXPathWrapNodeSet(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathWrapExternal(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathWrapExternal.");
  
  arg1 = getSwigCObjectPtr(args[0]);result = (xmlXPathObjectPtr)xmlXPathWrapExternal(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathEqualValues(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathEqualValues.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathEqualValues" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);result = (int)xmlXPathEqualValues(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNotEqualValues(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNotEqualValues.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNotEqualValues" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);result = (int)xmlXPathNotEqualValues(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCompareValues(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCompareValues.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathCompareValues" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathCompareValues" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlXPathCompareValues" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlXPathCompareValues(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathValueFlipSign(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathValueFlipSign.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathValueFlipSign" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);xmlXPathValueFlipSign(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathAddValues(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathAddValues.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathAddValues" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);xmlXPathAddValues(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathSubValues(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathSubValues.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathSubValues" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);xmlXPathSubValues(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathMultValues(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathMultValues.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathMultValues" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);xmlXPathMultValues(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathDivValues(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathDivValues.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathDivValues" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);xmlXPathDivValues(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathModValues(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathModValues.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathModValues" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);xmlXPathModValues(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathIsNodeType(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathIsNodeType.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathIsNodeType" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (int)xmlXPathIsNodeType((unsigned char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNextSelf(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNextSelf.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNextSelf" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNextSelf', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlXPathNextSelf(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNextChild(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNextChild.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNextChild" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNextChild', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlXPathNextChild(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNextDescendant(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNextDescendant.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNextDescendant" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNextDescendant', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlXPathNextDescendant(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNextDescendantOrSelf(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNextDescendantOrSelf.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNextDescendantOrSelf" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNextDescendantOrSelf', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlXPathNextDescendantOrSelf(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNextParent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNextParent.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNextParent" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNextParent', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlXPathNextParent(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNextAncestorOrSelf(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNextAncestorOrSelf.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNextAncestorOrSelf" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNextAncestorOrSelf', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlXPathNextAncestorOrSelf(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNextFollowingSibling(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNextFollowingSibling.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNextFollowingSibling" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNextFollowingSibling', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlXPathNextFollowingSibling(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNextFollowing(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNextFollowing.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNextFollowing" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNextFollowing', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlXPathNextFollowing(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNextNamespace(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNextNamespace.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNextNamespace" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNextNamespace', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlXPathNextNamespace(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNextAttribute(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNextAttribute.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNextAttribute" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNextAttribute', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlXPathNextAttribute(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNextPreceding(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNextPreceding.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNextPreceding" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNextPreceding', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlXPathNextPreceding(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNextAncestor(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNextAncestor.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNextAncestor" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNextAncestor', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlXPathNextAncestor(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNextPrecedingSibling(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlNodePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNextPrecedingSibling.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNextPrecedingSibling" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPathNextPrecedingSibling', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xmlNodePtr)xmlXPathNextPrecedingSibling(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathLastFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathLastFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathLastFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathLastFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathLastFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathPositionFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathPositionFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathPositionFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathPositionFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathPositionFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCountFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCountFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathCountFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathCountFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathCountFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathIdFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathIdFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathIdFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathIdFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathIdFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathLocalNameFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathLocalNameFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathLocalNameFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathLocalNameFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathLocalNameFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNamespaceURIFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNamespaceURIFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNamespaceURIFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathNamespaceURIFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathNamespaceURIFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathStringFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathStringFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathStringFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathStringFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathStringFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathStringLengthFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathStringLengthFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathStringLengthFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathStringLengthFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathStringLengthFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathConcatFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathConcatFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathConcatFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathConcatFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathConcatFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathContainsFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathContainsFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathContainsFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathContainsFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathContainsFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathStartsWithFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathStartsWithFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathStartsWithFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathStartsWithFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathStartsWithFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathSubstringFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathSubstringFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathSubstringFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathSubstringFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathSubstringFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathSubstringBeforeFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathSubstringBeforeFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathSubstringBeforeFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathSubstringBeforeFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathSubstringBeforeFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathSubstringAfterFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathSubstringAfterFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathSubstringAfterFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathSubstringAfterFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathSubstringAfterFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNormalizeFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNormalizeFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNormalizeFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathNormalizeFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathNormalizeFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathTranslateFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathTranslateFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathTranslateFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathTranslateFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathTranslateFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNotFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNotFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNotFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathNotFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathNotFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathTrueFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathTrueFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathTrueFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathTrueFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathTrueFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathFalseFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathFalseFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathFalseFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathFalseFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathFalseFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathLangFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathLangFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathLangFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathLangFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathLangFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNumberFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNumberFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathNumberFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathNumberFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathNumberFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathSumFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathSumFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathSumFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathSumFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathSumFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathFloorFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathFloorFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathFloorFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathFloorFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathFloorFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathCeilingFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathCeilingFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathCeilingFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathCeilingFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathCeilingFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathRoundFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathRoundFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathRoundFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathRoundFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathRoundFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathBooleanFunction(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathBooleanFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPathBooleanFunction" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPathBooleanFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlXPathBooleanFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPathNodeSetFreeNs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNsPtr arg1 = (xmlNsPtr) 0 ;
  int res1 ;
  void *arg10 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPathNodeSetFreeNs.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXPathNodeSetFreeNs', argument 1 of type 'xmlNsPtr'"); 
  }
  arg1 = (xmlNsPtr) arg10;xmlXPathNodeSetFreeNs(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_CATA_PREFER_NONE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CATA_PREFER_NONE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CATA_PREFER_PUBLIC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CATA_PREFER_PUBLIC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CATA_PREFER_SYSTEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CATA_PREFER_SYSTEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CATA_ALLOW_NONE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CATA_ALLOW_NONE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CATA_ALLOW_GLOBAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CATA_ALLOW_GLOBAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CATA_ALLOW_DOCUMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CATA_ALLOW_DOCUMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_CATA_ALLOW_ALL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_CATA_ALLOW_ALL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlNewCatalog(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  xmlCatalogPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewCatalog.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlNewCatalog" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (xmlCatalogPtr)xmlNewCatalog(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlCatalog, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlLoadACatalog(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlCatalogPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlLoadACatalog.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlLoadACatalog" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (xmlCatalogPtr)xmlLoadACatalog((char const *)arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlCatalog, 0 |  0 );
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlLoadSGMLSuperCatalog(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlCatalogPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlLoadSGMLSuperCatalog.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlLoadSGMLSuperCatalog" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (xmlCatalogPtr)xmlLoadSGMLSuperCatalog((char const *)arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlCatalog, 0 |  0 );
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlConvertSGMLCatalog(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCatalogPtr arg1 = (xmlCatalogPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlConvertSGMLCatalog.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlConvertSGMLCatalog" "', argument " "1"" of type '" "xmlCatalogPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlCatalogPtr >(argp1);result = (int)xmlConvertSGMLCatalog(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlACatalogAdd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCatalogPtr arg1 = (xmlCatalogPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlACatalogAdd.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlACatalogAdd" "', argument " "1"" of type '" "xmlCatalogPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlCatalogPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlACatalogAdd" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlACatalogAdd" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlACatalogAdd" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (int)xmlACatalogAdd(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlACatalogRemove(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCatalogPtr arg1 = (xmlCatalogPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlACatalogRemove.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlACatalogRemove" "', argument " "1"" of type '" "xmlCatalogPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlCatalogPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlACatalogRemove" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlACatalogRemove(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlACatalogResolve(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCatalogPtr arg1 = (xmlCatalogPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlACatalogResolve.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlACatalogResolve" "', argument " "1"" of type '" "xmlCatalogPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlCatalogPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlACatalogResolve" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlACatalogResolve" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlChar *)xmlACatalogResolve(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlACatalogResolveSystem(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCatalogPtr arg1 = (xmlCatalogPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlACatalogResolveSystem.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlACatalogResolveSystem" "', argument " "1"" of type '" "xmlCatalogPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlCatalogPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlACatalogResolveSystem" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlACatalogResolveSystem(arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlACatalogResolvePublic(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCatalogPtr arg1 = (xmlCatalogPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlACatalogResolvePublic.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlACatalogResolvePublic" "', argument " "1"" of type '" "xmlCatalogPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlCatalogPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlACatalogResolvePublic" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlACatalogResolvePublic(arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlACatalogResolveURI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCatalogPtr arg1 = (xmlCatalogPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlACatalogResolveURI.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlACatalogResolveURI" "', argument " "1"" of type '" "xmlCatalogPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlCatalogPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlACatalogResolveURI" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlACatalogResolveURI(arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlACatalogDump(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCatalogPtr arg1 = (xmlCatalogPtr) 0 ;
  FILE *arg2 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlACatalogDump.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlACatalogDump" "', argument " "1"" of type '" "xmlCatalogPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlCatalogPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlACatalogDump" "', argument " "2"" of type '" "FILE *""'"); 
  }
  arg2 = reinterpret_cast< FILE * >(argp2);xmlACatalogDump(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeCatalog(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCatalogPtr arg1 = (xmlCatalogPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeCatalog.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeCatalog" "', argument " "1"" of type '" "xmlCatalogPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlCatalogPtr >(argp1);xmlFreeCatalog(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogIsEmpty(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCatalogPtr arg1 = (xmlCatalogPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogIsEmpty.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlCatalog, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCatalogIsEmpty" "', argument " "1"" of type '" "xmlCatalogPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlCatalogPtr >(argp1);result = (int)xmlCatalogIsEmpty(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlInitializeCatalog(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlInitializeCatalog.");
  
  xmlInitializeCatalog();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlLoadCatalog(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlLoadCatalog.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlLoadCatalog" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (int)xmlLoadCatalog((char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlLoadCatalogs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlLoadCatalogs.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlLoadCatalogs" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }xmlLoadCatalogs((char const *)arg1);
  jsresult = SWIGV8_UNDEFINED();
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogCleanup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogCleanup.");
  
  xmlCatalogCleanup();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogDump(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogDump.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCatalogDump" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);xmlCatalogDump(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogResolve(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogResolve.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCatalogResolve" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCatalogResolve" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlCatalogResolve((unsigned char const *)arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogResolveSystem(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogResolveSystem.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCatalogResolveSystem" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlChar *)xmlCatalogResolveSystem((unsigned char const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogResolvePublic(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogResolvePublic.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCatalogResolvePublic" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlChar *)xmlCatalogResolvePublic((unsigned char const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogResolveURI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogResolveURI.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCatalogResolveURI" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlChar *)xmlCatalogResolveURI((unsigned char const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogAdd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogAdd.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCatalogAdd" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCatalogAdd" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlCatalogAdd" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (int)xmlCatalogAdd((unsigned char const *)arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogRemove(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogRemove.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCatalogRemove" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (int)xmlCatalogRemove((unsigned char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseCatalogFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseCatalogFile.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseCatalogFile" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (xmlDocPtr)xmlParseCatalogFile((char const *)arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogConvert(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogConvert.");
  
  result = (int)xmlCatalogConvert();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogFreeLocal(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogFreeLocal.");
  
  arg1 = getSwigCObjectPtr(args[0]);xmlCatalogFreeLocal(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogAddLocal(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogAddLocal.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCatalogAddLocal" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (void *)xmlCatalogAddLocal(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogLocalResolve(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogLocalResolve.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCatalogLocalResolve" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlCatalogLocalResolve" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlChar *)xmlCatalogLocalResolve(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogLocalResolveURI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogLocalResolveURI.");
  
  arg1 = getSwigCObjectPtr(args[0]);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCatalogLocalResolveURI" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlCatalogLocalResolveURI(arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogSetDebug(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogSetDebug.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlCatalogSetDebug" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlCatalogSetDebug(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogSetDefaultPrefer(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCatalogPrefer arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  xmlCatalogPrefer result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogSetDefaultPrefer.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlCatalogSetDefaultPrefer" "', argument " "1"" of type '" "xmlCatalogPrefer""'");
  } 
  arg1 = static_cast< xmlCatalogPrefer >(val1);result = (xmlCatalogPrefer)xmlCatalogSetDefaultPrefer(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogSetDefaults(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCatalogAllow arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogSetDefaults.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlCatalogSetDefaults" "', argument " "1"" of type '" "xmlCatalogAllow""'");
  } 
  arg1 = static_cast< xmlCatalogAllow >(val1);xmlCatalogSetDefaults(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogGetDefaults(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCatalogAllow result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogGetDefaults.");
  
  result = (xmlCatalogAllow)xmlCatalogGetDefaults();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogGetSystem(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogGetSystem.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCatalogGetSystem" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlChar *)xmlCatalogGetSystem((unsigned char const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCatalogGetPublic(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCatalogGetPublic.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCatalogGetPublic" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlChar *)xmlCatalogGetPublic((unsigned char const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap__xmlChSRange_low_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlChSRange *arg1 = (_xmlChSRange *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlChSRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlChSRange_low_set" "', argument " "1"" of type '" "_xmlChSRange *""'"); 
  }
  arg1 = reinterpret_cast< _xmlChSRange * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_short(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlChSRange_low_set" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);if (arg1) (arg1)->low = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlChSRange_low_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlChSRange *arg1 = (_xmlChSRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlChSRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlChSRange_low_get" "', argument " "1"" of type '" "_xmlChSRange *""'"); 
  }
  arg1 = reinterpret_cast< _xmlChSRange * >(argp1);result = (unsigned short) ((arg1)->low);
  jsresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlChSRange_high_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlChSRange *arg1 = (_xmlChSRange *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlChSRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlChSRange_high_set" "', argument " "1"" of type '" "_xmlChSRange *""'"); 
  }
  arg1 = reinterpret_cast< _xmlChSRange * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_short(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlChSRange_high_set" "', argument " "2"" of type '" "unsigned short""'");
  } 
  arg2 = static_cast< unsigned short >(val2);if (arg1) (arg1)->high = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlChSRange_high_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlChSRange *arg1 = (_xmlChSRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlChSRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlChSRange_high_get" "', argument " "1"" of type '" "_xmlChSRange *""'"); 
  }
  arg1 = reinterpret_cast< _xmlChSRange * >(argp1);result = (unsigned short) ((arg1)->high);
  jsresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlChSRange(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlChSRange *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlChSRange.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlChSRange.");
  result = (_xmlChSRange *)new _xmlChSRange();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlChSRange, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlChSRange(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlChSRange * arg1 = (_xmlChSRange *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlChLRange_low_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlChLRange *arg1 = (_xmlChLRange *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlChLRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlChLRange_low_set" "', argument " "1"" of type '" "_xmlChLRange *""'"); 
  }
  arg1 = reinterpret_cast< _xmlChLRange * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlChLRange_low_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);if (arg1) (arg1)->low = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlChLRange_low_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlChLRange *arg1 = (_xmlChLRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlChLRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlChLRange_low_get" "', argument " "1"" of type '" "_xmlChLRange *""'"); 
  }
  arg1 = reinterpret_cast< _xmlChLRange * >(argp1);result = (unsigned int) ((arg1)->low);
  jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlChLRange_high_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlChLRange *arg1 = (_xmlChLRange *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlChLRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlChLRange_high_set" "', argument " "1"" of type '" "_xmlChLRange *""'"); 
  }
  arg1 = reinterpret_cast< _xmlChLRange * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlChLRange_high_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);if (arg1) (arg1)->high = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlChLRange_high_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlChLRange *arg1 = (_xmlChLRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlChLRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlChLRange_high_get" "', argument " "1"" of type '" "_xmlChLRange *""'"); 
  }
  arg1 = reinterpret_cast< _xmlChLRange * >(argp1);result = (unsigned int) ((arg1)->high);
  jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlChLRange(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlChLRange *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlChLRange.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlChLRange.");
  result = (_xmlChLRange *)new _xmlChLRange();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlChLRange, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlChLRange(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlChLRange * arg1 = (_xmlChLRange *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlChRangeGroup_nbShortRange_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlChRangeGroup *arg1 = (_xmlChRangeGroup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlChRangeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlChRangeGroup_nbShortRange_set" "', argument " "1"" of type '" "_xmlChRangeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlChRangeGroup * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlChRangeGroup_nbShortRange_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nbShortRange = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlChRangeGroup_nbShortRange_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlChRangeGroup *arg1 = (_xmlChRangeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlChRangeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlChRangeGroup_nbShortRange_get" "', argument " "1"" of type '" "_xmlChRangeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlChRangeGroup * >(argp1);result = (int) ((arg1)->nbShortRange);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlChRangeGroup_nbLongRange_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlChRangeGroup *arg1 = (_xmlChRangeGroup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlChRangeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlChRangeGroup_nbLongRange_set" "', argument " "1"" of type '" "_xmlChRangeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlChRangeGroup * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlChRangeGroup_nbLongRange_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->nbLongRange = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlChRangeGroup_nbLongRange_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlChRangeGroup *arg1 = (_xmlChRangeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlChRangeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlChRangeGroup_nbLongRange_get" "', argument " "1"" of type '" "_xmlChRangeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlChRangeGroup * >(argp1);result = (int) ((arg1)->nbLongRange);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlChRangeGroup_shortRange_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlChRangeGroup *arg1 = (_xmlChRangeGroup *) 0 ;
  xmlChSRange *arg2 = (xmlChSRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlChRangeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlChRangeGroup_shortRange_set" "', argument " "1"" of type '" "_xmlChRangeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlChRangeGroup * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlChSRange, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlChRangeGroup_shortRange_set" "', argument " "2"" of type '" "xmlChSRange const *""'"); 
  }
  arg2 = reinterpret_cast< xmlChSRange * >(argp2);if (arg1) (arg1)->shortRange = (xmlChSRange const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlChRangeGroup_shortRange_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlChRangeGroup *arg1 = (_xmlChRangeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChSRange *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlChRangeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlChRangeGroup_shortRange_get" "', argument " "1"" of type '" "_xmlChRangeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlChRangeGroup * >(argp1);result = (xmlChSRange *) ((arg1)->shortRange);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlChSRange, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlChRangeGroup_longRange_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlChRangeGroup *arg1 = (_xmlChRangeGroup *) 0 ;
  xmlChLRange *arg2 = (xmlChLRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlChRangeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlChRangeGroup_longRange_set" "', argument " "1"" of type '" "_xmlChRangeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlChRangeGroup * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlChLRange, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlChRangeGroup_longRange_set" "', argument " "2"" of type '" "xmlChLRange const *""'"); 
  }
  arg2 = reinterpret_cast< xmlChLRange * >(argp2);if (arg1) (arg1)->longRange = (xmlChLRange const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlChRangeGroup_longRange_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlChRangeGroup *arg1 = (_xmlChRangeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChLRange *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlChRangeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlChRangeGroup_longRange_get" "', argument " "1"" of type '" "_xmlChRangeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlChRangeGroup * >(argp1);result = (xmlChLRange *) ((arg1)->longRange);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlChLRange, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlChRangeGroup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlChRangeGroup *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlChRangeGroup.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlChRangeGroup.");
  result = (_xmlChRangeGroup *)new _xmlChRangeGroup();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlChRangeGroup, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlChRangeGroup(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlChRangeGroup * arg1 = (_xmlChRangeGroup *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap_xmlCharInRange(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned int arg1 ;
  xmlChRangeGroup *arg2 = (xmlChRangeGroup *) 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCharInRange.");
  
  ecode1 = SWIG_AsVal_unsigned_SS_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlCharInRange" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlChRangeGroup, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCharInRange" "', argument " "2"" of type '" "xmlChRangeGroup const *""'"); 
  }
  arg2 = reinterpret_cast< xmlChRangeGroup * >(argp2);result = (int)xmlCharInRange(arg1,(_xmlChRangeGroup const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlIsBaseCharGroup_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChRangeGroup *result = 0 ;
  
  result = (xmlChRangeGroup *)&xmlIsBaseCharGroup;
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlChRangeGroup, 0 |  0 );
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlIsCharGroup_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChRangeGroup *result = 0 ;
  
  result = (xmlChRangeGroup *)&xmlIsCharGroup;
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlChRangeGroup, 0 |  0 );
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlIsCombiningGroup_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChRangeGroup *result = 0 ;
  
  result = (xmlChRangeGroup *)&xmlIsCombiningGroup;
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlChRangeGroup, 0 |  0 );
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlIsDigitGroup_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChRangeGroup *result = 0 ;
  
  result = (xmlChRangeGroup *)&xmlIsDigitGroup;
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlChRangeGroup, 0 |  0 );
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlIsExtenderGroup_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChRangeGroup *result = 0 ;
  
  result = (xmlChRangeGroup *)&xmlIsExtenderGroup;
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlChRangeGroup, 0 |  0 );
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlIsIdeographicGroup_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChRangeGroup *result = 0 ;
  
  result = (xmlChRangeGroup *)&xmlIsIdeographicGroup;
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlChRangeGroup, 0 |  0 );
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlIsPubidChar_tab_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned char *result = 0 ;
  
  result = (unsigned char *)(unsigned char *)xmlIsPubidChar_tab;
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlIsBaseChar(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlIsBaseChar.");
  
  ecode1 = SWIG_AsVal_unsigned_SS_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlIsBaseChar" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);result = (int)xmlIsBaseChar(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlIsBlank(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlIsBlank.");
  
  ecode1 = SWIG_AsVal_unsigned_SS_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlIsBlank" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);result = (int)xmlIsBlank(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlIsChar(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlIsChar.");
  
  ecode1 = SWIG_AsVal_unsigned_SS_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlIsChar" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);result = (int)xmlIsChar(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlIsCombining(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlIsCombining.");
  
  ecode1 = SWIG_AsVal_unsigned_SS_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlIsCombining" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);result = (int)xmlIsCombining(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlIsDigit(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlIsDigit.");
  
  ecode1 = SWIG_AsVal_unsigned_SS_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlIsDigit" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);result = (int)xmlIsDigit(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlIsExtender(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlIsExtender.");
  
  ecode1 = SWIG_AsVal_unsigned_SS_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlIsExtender" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);result = (int)xmlIsExtender(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlIsIdeographic(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlIsIdeographic.");
  
  ecode1 = SWIG_AsVal_unsigned_SS_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlIsIdeographic" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);result = (int)xmlIsIdeographic(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlIsPubidChar(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlIsPubidChar.");
  
  ecode1 = SWIG_AsVal_unsigned_SS_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlIsPubidChar" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);result = (int)xmlIsPubidChar(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap__htmlElemDesc_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_name_set" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_htmlElemDesc_name_set" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
    arg1->name = (char const *)reinterpret_cast< char* >(memcpy(new char[size], arg2, sizeof(char)*(size)));
  } else {
    arg1->name = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__htmlElemDesc_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_name_get" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);result = (char *) ((arg1)->name);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__htmlElemDesc_startTag_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_startTag_set" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);ecode2 = SWIG_AsVal_char(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_htmlElemDesc_startTag_set" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);if (arg1) (arg1)->startTag = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__htmlElemDesc_startTag_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_startTag_get" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);result = (char) ((arg1)->startTag);
  jsresult = SWIG_From_char(static_cast< char >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__htmlElemDesc_endTag_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_endTag_set" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);ecode2 = SWIG_AsVal_char(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_htmlElemDesc_endTag_set" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);if (arg1) (arg1)->endTag = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__htmlElemDesc_endTag_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_endTag_get" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);result = (char) ((arg1)->endTag);
  jsresult = SWIG_From_char(static_cast< char >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__htmlElemDesc_saveEndTag_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_saveEndTag_set" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);ecode2 = SWIG_AsVal_char(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_htmlElemDesc_saveEndTag_set" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);if (arg1) (arg1)->saveEndTag = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__htmlElemDesc_saveEndTag_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_saveEndTag_get" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);result = (char) ((arg1)->saveEndTag);
  jsresult = SWIG_From_char(static_cast< char >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__htmlElemDesc_empty_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_empty_set" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);ecode2 = SWIG_AsVal_char(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_htmlElemDesc_empty_set" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);if (arg1) (arg1)->empty = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__htmlElemDesc_empty_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_empty_get" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);result = (char) ((arg1)->empty);
  jsresult = SWIG_From_char(static_cast< char >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__htmlElemDesc_depr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_depr_set" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);ecode2 = SWIG_AsVal_char(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_htmlElemDesc_depr_set" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);if (arg1) (arg1)->depr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__htmlElemDesc_depr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_depr_get" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);result = (char) ((arg1)->depr);
  jsresult = SWIG_From_char(static_cast< char >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__htmlElemDesc_dtd_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_dtd_set" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);ecode2 = SWIG_AsVal_char(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_htmlElemDesc_dtd_set" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);if (arg1) (arg1)->dtd = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__htmlElemDesc_dtd_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_dtd_get" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);result = (char) ((arg1)->dtd);
  jsresult = SWIG_From_char(static_cast< char >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__htmlElemDesc_isinline_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_isinline_set" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);ecode2 = SWIG_AsVal_char(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_htmlElemDesc_isinline_set" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);if (arg1) (arg1)->isinline = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__htmlElemDesc_isinline_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_isinline_get" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);result = (char) ((arg1)->isinline);
  jsresult = SWIG_From_char(static_cast< char >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__htmlElemDesc_desc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_desc_set" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_htmlElemDesc_desc_set" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
    arg1->desc = (char const *)reinterpret_cast< char* >(memcpy(new char[size], arg2, sizeof(char)*(size)));
  } else {
    arg1->desc = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__htmlElemDesc_desc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_desc_get" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);result = (char *) ((arg1)->desc);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__htmlElemDesc_subelts_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_subelts_set" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_htmlElemDesc_subelts_set" "', argument " "2"" of type '" "char const **""'"); 
  }
  arg2 = reinterpret_cast< char ** >(argp2);if (arg1) (arg1)->subelts = (char const **)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__htmlElemDesc_subelts_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char **result = 0 ;
  char *temp ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_subelts_get" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);result = (char **) ((arg1)->subelts);
  {
    temp = (char*) result;
    jsresult = SWIGV8_STRING_NEW2(temp, strlen(temp));
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__htmlElemDesc_defaultsubelt_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_defaultsubelt_set" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_htmlElemDesc_defaultsubelt_set" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
    arg1->defaultsubelt = (char const *)reinterpret_cast< char* >(memcpy(new char[size], arg2, sizeof(char)*(size)));
  } else {
    arg1->defaultsubelt = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__htmlElemDesc_defaultsubelt_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_defaultsubelt_get" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);result = (char *) ((arg1)->defaultsubelt);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__htmlElemDesc_attrs_opt_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_attrs_opt_set" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_htmlElemDesc_attrs_opt_set" "', argument " "2"" of type '" "char const **""'"); 
  }
  arg2 = reinterpret_cast< char ** >(argp2);if (arg1) (arg1)->attrs_opt = (char const **)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__htmlElemDesc_attrs_opt_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char **result = 0 ;
  char *temp ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_attrs_opt_get" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);result = (char **) ((arg1)->attrs_opt);
  {
    temp = (char*) result;
    jsresult = SWIGV8_STRING_NEW2(temp, strlen(temp));
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__htmlElemDesc_attrs_depr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_attrs_depr_set" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_htmlElemDesc_attrs_depr_set" "', argument " "2"" of type '" "char const **""'"); 
  }
  arg2 = reinterpret_cast< char ** >(argp2);if (arg1) (arg1)->attrs_depr = (char const **)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__htmlElemDesc_attrs_depr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char **result = 0 ;
  char *temp ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_attrs_depr_get" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);result = (char **) ((arg1)->attrs_depr);
  {
    temp = (char*) result;
    jsresult = SWIGV8_STRING_NEW2(temp, strlen(temp));
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__htmlElemDesc_attrs_req_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_attrs_req_set" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_htmlElemDesc_attrs_req_set" "', argument " "2"" of type '" "char const **""'"); 
  }
  arg2 = reinterpret_cast< char ** >(argp2);if (arg1) (arg1)->attrs_req = (char const **)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__htmlElemDesc_attrs_req_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _htmlElemDesc *arg1 = (_htmlElemDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char **result = 0 ;
  char *temp ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlElemDesc_attrs_req_get" "', argument " "1"" of type '" "_htmlElemDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlElemDesc * >(argp1);result = (char **) ((arg1)->attrs_req);
  {
    temp = (char*) result;
    jsresult = SWIGV8_STRING_NEW2(temp, strlen(temp));
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__htmlElemDesc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _htmlElemDesc *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__htmlElemDesc.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__htmlElemDesc.");
  result = (_htmlElemDesc *)new _htmlElemDesc();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__htmlElemDesc, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__htmlElemDesc(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _htmlElemDesc * arg1 = (_htmlElemDesc *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__htmlEntityDesc_value_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _htmlEntityDesc *arg1 = (_htmlEntityDesc *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlEntityDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlEntityDesc_value_set" "', argument " "1"" of type '" "_htmlEntityDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlEntityDesc * >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_htmlEntityDesc_value_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);if (arg1) (arg1)->value = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__htmlEntityDesc_value_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _htmlEntityDesc *arg1 = (_htmlEntityDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlEntityDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlEntityDesc_value_get" "', argument " "1"" of type '" "_htmlEntityDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlEntityDesc * >(argp1);result = (unsigned int) ((arg1)->value);
  jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__htmlEntityDesc_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _htmlEntityDesc *arg1 = (_htmlEntityDesc *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlEntityDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlEntityDesc_name_set" "', argument " "1"" of type '" "_htmlEntityDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlEntityDesc * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_htmlEntityDesc_name_set" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
    arg1->name = (char const *)reinterpret_cast< char* >(memcpy(new char[size], arg2, sizeof(char)*(size)));
  } else {
    arg1->name = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__htmlEntityDesc_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _htmlEntityDesc *arg1 = (_htmlEntityDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlEntityDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlEntityDesc_name_get" "', argument " "1"" of type '" "_htmlEntityDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlEntityDesc * >(argp1);result = (char *) ((arg1)->name);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__htmlEntityDesc_desc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _htmlEntityDesc *arg1 = (_htmlEntityDesc *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlEntityDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlEntityDesc_desc_set" "', argument " "1"" of type '" "_htmlEntityDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlEntityDesc * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_htmlEntityDesc_desc_set" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1;
    arg1->desc = (char const *)reinterpret_cast< char* >(memcpy(new char[size], arg2, sizeof(char)*(size)));
  } else {
    arg1->desc = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__htmlEntityDesc_desc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _htmlEntityDesc *arg1 = (_htmlEntityDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__htmlEntityDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_htmlEntityDesc_desc_get" "', argument " "1"" of type '" "_htmlEntityDesc *""'"); 
  }
  arg1 = reinterpret_cast< _htmlEntityDesc * >(argp1);result = (char *) ((arg1)->desc);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__htmlEntityDesc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _htmlEntityDesc *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__htmlEntityDesc.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__htmlEntityDesc.");
  result = (_htmlEntityDesc *)new _htmlEntityDesc();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__htmlEntityDesc, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__htmlEntityDesc(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _htmlEntityDesc * arg1 = (_htmlEntityDesc *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap_htmlDefaultSAXHandler_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerV1 *result = 0 ;
  
  result = (xmlSAXHandlerV1 *)&htmlDefaultSAXHandler;
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap___htmlDefaultSAXHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerV1 *result = 0 ;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___htmlDefaultSAXHandler.");
  
  result = (xmlSAXHandlerV1 *)__htmlDefaultSAXHandler();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlInitAutoClose(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlInitAutoClose.");
  
  htmlInitAutoClose();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlTagLookup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  htmlElemDesc *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlTagLookup.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlTagLookup" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (htmlElemDesc *)htmlTagLookup((unsigned char const *)arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlEntityLookup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  htmlEntityDesc *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlEntityLookup.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlEntityLookup" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (htmlEntityDesc *)htmlEntityLookup((unsigned char const *)arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__htmlEntityDesc, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlEntityValueLookup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  htmlEntityDesc *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlEntityValueLookup.");
  
  ecode1 = SWIG_AsVal_unsigned_SS_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "htmlEntityValueLookup" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);result = (htmlEntityDesc *)htmlEntityValueLookup(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__htmlEntityDesc, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlIsAutoClosed(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlDocPtr arg1 = (htmlDocPtr) 0 ;
  htmlNodePtr arg2 = (htmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlIsAutoClosed.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'htmlIsAutoClosed', argument 1 of type 'htmlDocPtr'"); 
  }
  arg1 = (htmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'htmlIsAutoClosed', argument 2 of type 'htmlNodePtr'"); 
    }
  }
  
  arg2 = ((htmlNodePtr) arg20);result = (int)htmlIsAutoClosed(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlAutoCloseTag(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlDocPtr arg1 = (htmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  htmlNodePtr arg3 = (htmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  void *arg30 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlAutoCloseTag.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'htmlAutoCloseTag', argument 1 of type 'htmlDocPtr'"); 
  }
  arg1 = (htmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlAutoCloseTag" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'htmlAutoCloseTag', argument 3 of type 'htmlNodePtr'"); 
    }
  }
  
  arg3 = ((htmlNodePtr) arg30);result = (int)htmlAutoCloseTag(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlParseEntityRef(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlParserCtxtPtr arg1 = (htmlParserCtxtPtr) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  htmlEntityDesc *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlParseEntityRef.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlParseEntityRef" "', argument " "1"" of type '" "htmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< htmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlParseEntityRef" "', argument " "2"" of type '" "xmlChar const **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);result = (htmlEntityDesc *)htmlParseEntityRef(arg1,(unsigned char const **)arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__htmlEntityDesc, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlParseCharRef(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlParserCtxtPtr arg1 = (htmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlParseCharRef.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlParseCharRef" "', argument " "1"" of type '" "htmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< htmlParserCtxtPtr >(argp1);result = (int)htmlParseCharRef(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlParseElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlParserCtxtPtr arg1 = (htmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlParseElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlParseElement" "', argument " "1"" of type '" "htmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< htmlParserCtxtPtr >(argp1);htmlParseElement(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlNewParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlParserCtxtPtr result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlNewParserCtxt.");
  
  result = (htmlParserCtxtPtr)htmlNewParserCtxt();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlNewSAXParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlSAXHandler *arg1 = (htmlSAXHandler *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  htmlParserCtxtPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlNewSAXParserCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlNewSAXParserCtxt" "', argument " "1"" of type '" "htmlSAXHandler const *""'"); 
  }
  arg1 = reinterpret_cast< htmlSAXHandler * >(argp1);arg2 = getSwigCObjectPtr(args[1]);result = (htmlParserCtxtPtr)htmlNewSAXParserCtxt((_xmlSAXHandler const *)arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlCreateMemoryParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  htmlParserCtxtPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlCreateMemoryParserCtxt.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlCreateMemoryParserCtxt" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "htmlCreateMemoryParserCtxt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (htmlParserCtxtPtr)htmlCreateMemoryParserCtxt((char const *)arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  // free(arg1);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlParseDocument(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlParserCtxtPtr arg1 = (htmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlParseDocument.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlParseDocument" "', argument " "1"" of type '" "htmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< htmlParserCtxtPtr >(argp1);result = (int)htmlParseDocument(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlSAXParseDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  char *arg2 = (char *) 0 ;
  htmlSAXHandlerPtr arg3 = (htmlSAXHandlerPtr) 0 ;
  void *arg4 = (void *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  htmlDocPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlSAXParseDoc.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlSAXParseDoc" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlSAXParseDoc" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "htmlSAXParseDoc" "', argument " "3"" of type '" "htmlSAXHandlerPtr""'"); 
  }
  arg3 = reinterpret_cast< htmlSAXHandlerPtr >(argp3);arg4 = getSwigCObjectPtr(args[3]);result = (htmlDocPtr)htmlSAXParseDoc((unsigned char const *)arg1,(char const *)arg2,arg3,arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  // free(arg2);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlParseDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  htmlDocPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlParseDoc.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlParseDoc" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlParseDoc" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (htmlDocPtr)htmlParseDoc((unsigned char const *)arg1,(char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlCreateFileParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  htmlParserCtxtPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlCreateFileParserCtxt.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlCreateFileParserCtxt" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlCreateFileParserCtxt" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (htmlParserCtxtPtr)htmlCreateFileParserCtxt((char const *)arg1,(char const *)arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  // free(arg1);
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlSAXParseFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  htmlSAXHandlerPtr arg3 = (htmlSAXHandlerPtr) 0 ;
  void *arg4 = (void *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  htmlDocPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlSAXParseFile.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlSAXParseFile" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlSAXParseFile" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "htmlSAXParseFile" "', argument " "3"" of type '" "htmlSAXHandlerPtr""'"); 
  }
  arg3 = reinterpret_cast< htmlSAXHandlerPtr >(argp3);arg4 = getSwigCObjectPtr(args[3]);result = (htmlDocPtr)htmlSAXParseFile((char const *)arg1,(char const *)arg2,arg3,arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  // free(arg1);
  // free(arg2);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlParseFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  htmlDocPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlParseFile.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlParseFile" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlParseFile" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (htmlDocPtr)htmlParseFile((char const *)arg1,(char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  // free(arg1);
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_UTF8ToHtml(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned char *arg1 = (unsigned char *) 0 ;
  int *arg2 = (int *) 0 ;
  unsigned char *arg3 = (unsigned char *) 0 ;
  int *arg4 = (int *) 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 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_UTF8ToHtml.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UTF8ToHtml" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = reinterpret_cast< unsigned char * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UTF8ToHtml" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UTF8ToHtml" "', argument " "3"" of type '" "unsigned char const *""'"); 
  }
  arg3 = reinterpret_cast< unsigned char * >(argp3);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "UTF8ToHtml" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);result = (int)UTF8ToHtml(arg1,arg2,(unsigned char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlEncodeEntities(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned char *arg1 = (unsigned char *) 0 ;
  int *arg2 = (int *) 0 ;
  unsigned char *arg3 = (unsigned char *) 0 ;
  int *arg4 = (int *) 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 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 result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlEncodeEntities.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlEncodeEntities" "', argument " "1"" of type '" "unsigned char *""'"); 
  }
  arg1 = reinterpret_cast< unsigned char * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlEncodeEntities" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "htmlEncodeEntities" "', argument " "3"" of type '" "unsigned char const *""'"); 
  }
  arg3 = reinterpret_cast< unsigned char * >(argp3);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "htmlEncodeEntities" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "htmlEncodeEntities" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);result = (int)htmlEncodeEntities(arg1,arg2,(unsigned char const *)arg3,arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlIsScriptAttribute(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlIsScriptAttribute.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlIsScriptAttribute" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (int)htmlIsScriptAttribute((unsigned char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlHandleOmittedElem(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlHandleOmittedElem.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "htmlHandleOmittedElem" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)htmlHandleOmittedElem(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlCreatePushParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlSAXHandlerPtr arg1 = (htmlSAXHandlerPtr) 0 ;
  void *arg2 = (void *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  char *arg5 = (char *) 0 ;
  xmlCharEncoding arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  htmlParserCtxtPtr result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlCreatePushParserCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlCreatePushParserCtxt" "', argument " "1"" of type '" "htmlSAXHandlerPtr""'"); 
  }
  arg1 = reinterpret_cast< htmlSAXHandlerPtr >(argp1);arg2 = getSwigCObjectPtr(args[1]);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "htmlCreatePushParserCtxt" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "htmlCreatePushParserCtxt" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);if (args[4]->IsNull()) {
    arg5 = NULL;
  } else if (node::Buffer::HasInstance(args[4])) {
    arg5 = node::Buffer::Data(Nan::To<v8::Object>(args[4]).ToLocalChecked());
    // printf("data: %s - %i\n", arg5, strlen(arg5));
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "htmlCreatePushParserCtxt" "', argument " "5"" of type '" "char const *""'");
    }
    
    arg5 = reinterpret_cast< char * >(buf5);
  }ecode6 = SWIG_AsVal_int(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "htmlCreatePushParserCtxt" "', argument " "6"" of type '" "xmlCharEncoding""'");
  } 
  arg6 = static_cast< xmlCharEncoding >(val6);result = (htmlParserCtxtPtr)htmlCreatePushParserCtxt(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5,arg6);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  
  
  // free(arg3);
  
  // free(arg5);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlParseChunk(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlParserCtxtPtr arg1 = (htmlParserCtxtPtr) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlParseChunk.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlParseChunk" "', argument " "1"" of type '" "htmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< htmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlParseChunk" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "htmlParseChunk" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "htmlParseChunk" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (int)htmlParseChunk(arg1,(char const *)arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlFreeParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlParserCtxtPtr arg1 = (htmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlFreeParserCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlFreeParserCtxt" "', argument " "1"" of type '" "htmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< htmlParserCtxtPtr >(argp1);htmlFreeParserCtxt(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_HTML_PARSE_RECOVER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(HTML_PARSE_RECOVER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HTML_PARSE_NODEFDTD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(HTML_PARSE_NODEFDTD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HTML_PARSE_NOERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(HTML_PARSE_NOERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HTML_PARSE_NOWARNING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(HTML_PARSE_NOWARNING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HTML_PARSE_PEDANTIC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(HTML_PARSE_PEDANTIC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HTML_PARSE_NOBLANKS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(HTML_PARSE_NOBLANKS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HTML_PARSE_NONET_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(HTML_PARSE_NONET));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HTML_PARSE_NOIMPLIED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(HTML_PARSE_NOIMPLIED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HTML_PARSE_COMPACT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(HTML_PARSE_COMPACT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HTML_PARSE_IGNORE_ENC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(HTML_PARSE_IGNORE_ENC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_htmlCtxtReset(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlParserCtxtPtr arg1 = (htmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlCtxtReset.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlCtxtReset" "', argument " "1"" of type '" "htmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< htmlParserCtxtPtr >(argp1);htmlCtxtReset(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlCtxtUseOptions(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlParserCtxtPtr arg1 = (htmlParserCtxtPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlCtxtUseOptions.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlCtxtUseOptions" "', argument " "1"" of type '" "htmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< htmlParserCtxtPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "htmlCtxtUseOptions" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)htmlCtxtUseOptions(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlReadDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  htmlDocPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlReadDoc.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlReadDoc" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlReadDoc" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "htmlReadDoc" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "htmlReadDoc" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (htmlDocPtr)htmlReadDoc((unsigned char const *)arg1,(char const *)arg2,(char const *)arg3,arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  // free(arg2);
  // free(arg3);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlReadFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  htmlDocPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlReadFile.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlReadFile" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlReadFile" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "htmlReadFile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (htmlDocPtr)htmlReadFile((char const *)arg1,(char const *)arg2,arg3);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  // free(arg1);
  // free(arg2);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlReadMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int arg5 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  htmlDocPtr result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlReadMemory.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlReadMemory" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "htmlReadMemory" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "htmlReadMemory" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "htmlReadMemory" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "htmlReadMemory" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);result = (htmlDocPtr)htmlReadMemory((char const *)arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  // free(arg1);
  
  // free(arg3);
  // free(arg4);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlReadFd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  htmlDocPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlReadFd.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "htmlReadFd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlReadFd" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "htmlReadFd" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "htmlReadFd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (htmlDocPtr)htmlReadFd(arg1,(char const *)arg2,(char const *)arg3,arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  // free(arg2);
  // free(arg3);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlReadIO(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlInputReadCallback arg1 = (xmlInputReadCallback) 0 ;
  xmlInputCloseCallback arg2 = (xmlInputCloseCallback) 0 ;
  void *arg3 = (void *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  int arg6 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  htmlDocPtr result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlReadIO.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p_char_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "htmlReadIO" "', argument " "1"" of type '" "xmlInputReadCallback""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "htmlReadIO" "', argument " "2"" of type '" "xmlInputCloseCallback""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "htmlReadIO" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else if (node::Buffer::HasInstance(args[4])) {
    arg5 = node::Buffer::Data(Nan::To<v8::Object>(args[4]).ToLocalChecked());
    // printf("data: %s - %i\n", arg5, strlen(arg5));
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "htmlReadIO" "', argument " "5"" of type '" "char const *""'");
    }
    
    arg5 = reinterpret_cast< char * >(buf5);
  }ecode6 = SWIG_AsVal_int(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "htmlReadIO" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);result = (htmlDocPtr)htmlReadIO(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5,arg6);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  
  // free(arg4);
  // free(arg5);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlCtxtParseDocument(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlParserCtxtPtr arg1 = (htmlParserCtxtPtr) 0 ;
  xmlParserInputPtr arg2 = (xmlParserInputPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  htmlDocPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlCtxtParseDocument.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlCtxtParseDocument" "', argument " "1"" of type '" "htmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< htmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlCtxtParseDocument" "', argument " "2"" of type '" "xmlParserInputPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlParserInputPtr >(argp2);result = (htmlDocPtr)htmlCtxtParseDocument(arg1,arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlCtxtReadDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  htmlDocPtr result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlCtxtReadDoc.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlCtxtReadDoc" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlCtxtReadDoc" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "htmlCtxtReadDoc" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "htmlCtxtReadDoc" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "htmlCtxtReadDoc" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);result = (htmlDocPtr)htmlCtxtReadDoc(arg1,(unsigned char const *)arg2,(char const *)arg3,(char const *)arg4,arg5);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  // free(arg3);
  // free(arg4);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlCtxtReadFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  htmlDocPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlCtxtReadFile.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlCtxtReadFile" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlCtxtReadFile" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "htmlCtxtReadFile" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "htmlCtxtReadFile" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (htmlDocPtr)htmlCtxtReadFile(arg1,(char const *)arg2,(char const *)arg3,arg4);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  // free(arg2);
  // free(arg3);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlCtxtReadMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  htmlDocPtr result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlCtxtReadMemory.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlCtxtReadMemory" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlCtxtReadMemory" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "htmlCtxtReadMemory" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "htmlCtxtReadMemory" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else if (node::Buffer::HasInstance(args[4])) {
    arg5 = node::Buffer::Data(Nan::To<v8::Object>(args[4]).ToLocalChecked());
    // printf("data: %s - %i\n", arg5, strlen(arg5));
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "htmlCtxtReadMemory" "', argument " "5"" of type '" "char const *""'");
    }
    
    arg5 = reinterpret_cast< char * >(buf5);
  }ecode6 = SWIG_AsVal_int(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "htmlCtxtReadMemory" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);result = (htmlDocPtr)htmlCtxtReadMemory(arg1,(char const *)arg2,arg3,(char const *)arg4,(char const *)arg5,arg6);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  // free(arg2);
  
  // free(arg4);
  // free(arg5);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlCtxtReadFd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  htmlDocPtr result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlCtxtReadFd.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlCtxtReadFd" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "htmlCtxtReadFd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "htmlCtxtReadFd" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "htmlCtxtReadFd" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "htmlCtxtReadFd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);result = (htmlDocPtr)htmlCtxtReadFd(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  // free(arg3);
  // free(arg4);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlCtxtReadIO(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlInputReadCallback arg2 = (xmlInputReadCallback) 0 ;
  xmlInputCloseCallback arg3 = (xmlInputCloseCallback) 0 ;
  void *arg4 = (void *) 0 ;
  char *arg5 = (char *) 0 ;
  char *arg6 = (char *) 0 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  size_t size6 = 0 ;
  int alloc6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  htmlDocPtr result;
  
  if (args.Length() < 7 || args.Length() > 7) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlCtxtReadIO.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlCtxtReadIO" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_char_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "htmlCtxtReadIO" "', argument " "2"" of type '" "xmlInputReadCallback""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[2], (void**)(&arg3), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "htmlCtxtReadIO" "', argument " "3"" of type '" "xmlInputCloseCallback""'"); 
      }
    }
  }
  arg4 = getSwigCObjectPtr(args[3]);if (args[4]->IsNull()) {
    arg5 = NULL;
  } else if (node::Buffer::HasInstance(args[4])) {
    arg5 = node::Buffer::Data(Nan::To<v8::Object>(args[4]).ToLocalChecked());
    // printf("data: %s - %i\n", arg5, strlen(arg5));
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "htmlCtxtReadIO" "', argument " "5"" of type '" "char const *""'");
    }
    
    arg5 = reinterpret_cast< char * >(buf5);
  }if (args[5]->IsNull()) {
    arg6 = NULL;
  } else if (node::Buffer::HasInstance(args[5])) {
    arg6 = node::Buffer::Data(Nan::To<v8::Object>(args[5]).ToLocalChecked());
    // printf("data: %s - %i\n", arg6, strlen(arg6));
  } else {
    res6 = SWIG_AsCharPtrAndSize(args[5], &buf6, &size6, &alloc6);
    
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "htmlCtxtReadIO" "', argument " "6"" of type '" "char const *""'");
    }
    
    arg6 = reinterpret_cast< char * >(buf6);
  }ecode7 = SWIG_AsVal_int(args[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "htmlCtxtReadIO" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);result = (htmlDocPtr)htmlCtxtReadIO(arg1,arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,arg7);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  
  
  // free(arg5);
  // free(arg6);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_HTML_NA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(HTML_NA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HTML_INVALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(HTML_INVALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HTML_DEPRECATED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(HTML_DEPRECATED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HTML_VALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(HTML_VALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_HTML_REQUIRED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(HTML_REQUIRED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_htmlAttrAllowed(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlElemDesc *arg1 = (htmlElemDesc *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  htmlStatus result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlAttrAllowed.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlAttrAllowed" "', argument " "1"" of type '" "htmlElemDesc const *""'"); 
  }
  arg1 = reinterpret_cast< htmlElemDesc * >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlAttrAllowed" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "htmlAttrAllowed" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (htmlStatus)htmlAttrAllowed((_htmlElemDesc const *)arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlElementAllowedHere(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlElemDesc *arg1 = (htmlElemDesc *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlElementAllowedHere.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlElementAllowedHere" "', argument " "1"" of type '" "htmlElemDesc const *""'"); 
  }
  arg1 = reinterpret_cast< htmlElemDesc * >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlElementAllowedHere" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)htmlElementAllowedHere((_htmlElemDesc const *)arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlElementStatusHere(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlElemDesc *arg1 = (htmlElemDesc *) 0 ;
  htmlElemDesc *arg2 = (htmlElemDesc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  htmlStatus result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlElementStatusHere.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlElementStatusHere" "', argument " "1"" of type '" "htmlElemDesc const *""'"); 
  }
  arg1 = reinterpret_cast< htmlElemDesc * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__htmlElemDesc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlElementStatusHere" "', argument " "2"" of type '" "htmlElemDesc const *""'"); 
  }
  arg2 = reinterpret_cast< htmlElemDesc * >(argp2);result = (htmlStatus)htmlElementStatusHere((_htmlElemDesc const *)arg1,(_htmlElemDesc const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlNodeStatus(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlNodePtr arg1 = (htmlNodePtr) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  htmlStatus result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlNodeStatus.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'htmlNodeStatus', argument 1 of type 'htmlNodePtr'"); 
    }
  }
  
  arg1 = ((htmlNodePtr) arg10);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "htmlNodeStatus" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (htmlStatus)htmlNodeStatus(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_SAVE_FORMAT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SAVE_FORMAT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SAVE_NO_DECL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SAVE_NO_DECL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SAVE_NO_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SAVE_NO_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SAVE_NO_XHTML_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SAVE_NO_XHTML));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SAVE_XHTML_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SAVE_XHTML));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SAVE_AS_XML_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SAVE_AS_XML));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SAVE_AS_HTML_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SAVE_AS_HTML));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SAVE_WSNONSIG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SAVE_WSNONSIG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlSaveToFd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlSaveCtxtPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveToFd.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlSaveToFd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSaveToFd" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSaveToFd" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlSaveCtxtPtr)xmlSaveToFd(arg1,(char const *)arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSaveCtxt, 0 |  0 );
  
  // free(arg2);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSaveToFilename(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlSaveCtxtPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveToFilename.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSaveToFilename" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSaveToFilename" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSaveToFilename" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlSaveCtxtPtr)xmlSaveToFilename((char const *)arg1,(char const *)arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSaveCtxt, 0 |  0 );
  // free(arg1);
  // free(arg2);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSaveToBuffer(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlSaveCtxtPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveToBuffer.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSaveToBuffer" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSaveToBuffer" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSaveToBuffer" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlSaveCtxtPtr)xmlSaveToBuffer(arg1,(char const *)arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSaveCtxt, 0 |  0 );
  
  // free(arg2);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSaveToIO(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputWriteCallback arg1 = (xmlOutputWriteCallback) 0 ;
  xmlOutputCloseCallback arg2 = (xmlOutputCloseCallback) 0 ;
  void *arg3 = (void *) 0 ;
  char *arg4 = (char *) 0 ;
  int arg5 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  xmlSaveCtxtPtr result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveToIO.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p_q_const__char_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlSaveToIO" "', argument " "1"" of type '" "xmlOutputWriteCallback""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlSaveToIO" "', argument " "2"" of type '" "xmlOutputCloseCallback""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSaveToIO" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlSaveToIO" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);result = (xmlSaveCtxtPtr)xmlSaveToIO(arg1,arg2,arg3,(char const *)arg4,arg5);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSaveCtxt, 0 |  0 );
  
  
  
  // free(arg4);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSaveDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSaveCtxtPtr arg1 = (xmlSaveCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  long result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveDoc.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSaveCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSaveDoc" "', argument " "1"" of type '" "xmlSaveCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSaveCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlSaveDoc', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;result = (long)xmlSaveDoc(arg1,arg2);
  jsresult = SWIG_From_long(static_cast< long >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSaveTree(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSaveCtxtPtr arg1 = (xmlSaveCtxtPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  long result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveTree.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSaveCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSaveTree" "', argument " "1"" of type '" "xmlSaveCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSaveCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlSaveTree', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (long)xmlSaveTree(arg1,arg2);
  jsresult = SWIG_From_long(static_cast< long >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSaveFlush(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSaveCtxtPtr arg1 = (xmlSaveCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveFlush.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSaveCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSaveFlush" "', argument " "1"" of type '" "xmlSaveCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSaveCtxtPtr >(argp1);result = (int)xmlSaveFlush(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSaveClose(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSaveCtxtPtr arg1 = (xmlSaveCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveClose.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSaveCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSaveClose" "', argument " "1"" of type '" "xmlSaveCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSaveCtxtPtr >(argp1);result = (int)xmlSaveClose(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSaveFinish(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSaveCtxtPtr arg1 = (xmlSaveCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveFinish.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSaveCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSaveFinish" "', argument " "1"" of type '" "xmlSaveCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSaveCtxtPtr >(argp1);result = (int)xmlSaveFinish(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSaveSetEscape(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSaveCtxtPtr arg1 = (xmlSaveCtxtPtr) 0 ;
  xmlCharEncodingOutputFunc arg2 = (xmlCharEncodingOutputFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveSetEscape.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSaveCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSaveSetEscape" "', argument " "1"" of type '" "xmlSaveCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSaveCtxtPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_unsigned_char_p_int_p_q_const__unsigned_char_p_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlSaveSetEscape" "', argument " "2"" of type '" "xmlCharEncodingOutputFunc""'"); 
      }
    }
  }
  result = (int)xmlSaveSetEscape(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSaveSetAttrEscape(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSaveCtxtPtr arg1 = (xmlSaveCtxtPtr) 0 ;
  xmlCharEncodingOutputFunc arg2 = (xmlCharEncodingOutputFunc) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveSetAttrEscape.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSaveCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSaveSetAttrEscape" "', argument " "1"" of type '" "xmlSaveCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSaveCtxtPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_unsigned_char_p_int_p_q_const__unsigned_char_p_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlSaveSetAttrEscape" "', argument " "2"" of type '" "xmlCharEncodingOutputFunc""'"); 
      }
    }
  }
  result = (int)xmlSaveSetAttrEscape(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefIndentTreeOutput(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefIndentTreeOutput.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlThrDefIndentTreeOutput" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlThrDefIndentTreeOutput(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefTreeIndentString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  char *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefTreeIndentString.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlThrDefTreeIndentString" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (char *)xmlThrDefTreeIndentString((char const *)arg1);
  jsresult = SWIG_FromCharPtr((const char *)result);
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlThrDefSaveNoEmptyTags(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlThrDefSaveNoEmptyTags.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlThrDefSaveNoEmptyTags" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlThrDefSaveNoEmptyTags(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlInitializeGlobalState(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlGlobalStatePtr arg1 = (xmlGlobalStatePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlInitializeGlobalState.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlGlobalState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlInitializeGlobalState" "', argument " "1"" of type '" "xmlGlobalStatePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlGlobalStatePtr >(argp1);xmlInitializeGlobalState(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetGlobalState(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlGlobalStatePtr result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetGlobalState.");
  
  result = (xmlGlobalStatePtr)xmlGetGlobalState();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlGlobalState, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlNewDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  htmlDocPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlNewDoc.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlNewDoc" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlNewDoc" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (htmlDocPtr)htmlNewDoc((unsigned char const *)arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlNewDocNoDtD(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  htmlDocPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlNewDocNoDtD.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlNewDocNoDtD" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlNewDocNoDtD" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (htmlDocPtr)htmlNewDocNoDtD((unsigned char const *)arg1,(unsigned char const *)arg2);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlGetMetaEncoding(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlDocPtr arg1 = (htmlDocPtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlGetMetaEncoding.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'htmlGetMetaEncoding', argument 1 of type 'htmlDocPtr'"); 
  }
  arg1 = (htmlDocPtr) arg10;result = (xmlChar *)htmlGetMetaEncoding(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlSetMetaEncoding(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  htmlDocPtr arg1 = (htmlDocPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlSetMetaEncoding.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'htmlSetMetaEncoding', argument 1 of type 'htmlDocPtr'"); 
  }
  arg1 = (htmlDocPtr) arg10;if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlSetMetaEncoding" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)htmlSetMetaEncoding(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlDocDumpMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  int *arg3 = (int *) 0 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlDocDumpMemory.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'htmlDocDumpMemory', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlDocDumpMemory" "', argument " "2"" of type '" "xmlChar **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "htmlDocDumpMemory" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);htmlDocDumpMemory(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlDocDumpMemoryFormat(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  int *arg3 = (int *) 0 ;
  int arg4 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlDocDumpMemoryFormat.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'htmlDocDumpMemoryFormat', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "htmlDocDumpMemoryFormat" "', argument " "2"" of type '" "xmlChar **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "htmlDocDumpMemoryFormat" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "htmlDocDumpMemoryFormat" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);htmlDocDumpMemoryFormat(arg1,arg2,arg3,arg4);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlDocDump(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlDocDump.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlDocDump" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'htmlDocDump', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;result = (int)htmlDocDump(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlSaveFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlSaveFile.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlSaveFile" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'htmlSaveFile', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;result = (int)htmlSaveFile((char const *)arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  // free(arg1);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlNodeDump(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlNodeDump.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlNodeDump" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'htmlNodeDump', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'htmlNodeDump', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);result = (int)htmlNodeDump(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlNodeDumpFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlNodeDumpFile.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlNodeDumpFile" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'htmlNodeDumpFile', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'htmlNodeDumpFile', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);htmlNodeDumpFile(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlNodeDumpFileFormat(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  char *arg4 = (char *) 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlNodeDumpFileFormat.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlNodeDumpFileFormat" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'htmlNodeDumpFileFormat', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'htmlNodeDumpFileFormat', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "htmlNodeDumpFileFormat" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "htmlNodeDumpFileFormat" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);result = (int)htmlNodeDumpFileFormat(arg1,arg2,arg3,(char const *)arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  // free(arg4);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlSaveFileEnc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  char *arg3 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlSaveFileEnc.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlSaveFileEnc" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'htmlSaveFileEnc', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "htmlSaveFileEnc" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }result = (int)htmlSaveFileEnc((char const *)arg1,arg2,(char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  // free(arg1);
  
  // free(arg3);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlSaveFileFormat(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlSaveFileFormat.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlSaveFileFormat" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'htmlSaveFileFormat', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "htmlSaveFileFormat" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "htmlSaveFileFormat" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (int)htmlSaveFileFormat((char const *)arg1,arg2,(char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  // free(arg1);
  
  // free(arg3);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlNodeDumpFormatOutput(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferPtr arg1 = (xmlOutputBufferPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  char *arg4 = (char *) 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlNodeDumpFormatOutput.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlNodeDumpFormatOutput" "', argument " "1"" of type '" "xmlOutputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlOutputBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'htmlNodeDumpFormatOutput', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'htmlNodeDumpFormatOutput', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "htmlNodeDumpFormatOutput" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "htmlNodeDumpFormatOutput" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);htmlNodeDumpFormatOutput(arg1,arg2,arg3,(char const *)arg4,arg5);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  // free(arg4);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlDocContentDumpOutput(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferPtr arg1 = (xmlOutputBufferPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlDocContentDumpOutput.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlDocContentDumpOutput" "', argument " "1"" of type '" "xmlOutputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlOutputBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'htmlDocContentDumpOutput', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "htmlDocContentDumpOutput" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }htmlDocContentDumpOutput(arg1,arg2,(char const *)arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  // free(arg3);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlDocContentDumpFormatOutput(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferPtr arg1 = (xmlOutputBufferPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlDocContentDumpFormatOutput.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlDocContentDumpFormatOutput" "', argument " "1"" of type '" "xmlOutputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlOutputBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'htmlDocContentDumpFormatOutput', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "htmlDocContentDumpFormatOutput" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "htmlDocContentDumpFormatOutput" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);htmlDocContentDumpFormatOutput(arg1,arg2,(char const *)arg3,arg4);
  jsresult = SWIGV8_UNDEFINED();
  
  
  // free(arg3);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlNodeDumpOutput(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferPtr arg1 = (xmlOutputBufferPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlNodeDumpOutput.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlNodeDumpOutput" "', argument " "1"" of type '" "xmlOutputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlOutputBufferPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'htmlNodeDumpOutput', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'htmlNodeDumpOutput', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "htmlNodeDumpOutput" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }htmlNodeDumpOutput(arg1,arg2,arg3,(char const *)arg4);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  // free(arg4);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_htmlIsBooleanAttr(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_htmlIsBooleanAttr.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlIsBooleanAttr" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (int)htmlIsBooleanAttr((unsigned char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserMaxDepth_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned int result;
  
  result = (unsigned int)(unsigned int)xmlParserMaxDepth;
  jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_MAX_TEXT_LENGTH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(10000000));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_MAX_HUGE_LENGTH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1000000000));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_MAX_NAME_LENGTH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(50000));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_MAX_DICTIONARY_LIMIT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(10000000));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_MAX_LOOKUP_LIMIT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(10000000));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_MAX_NAMELEN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(100));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_INPUT_CHUNK_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(250));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlStringText_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *result = 0 ;
  
  result = (xmlChar *)(xmlChar *)xmlStringText;
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlStringTextNoenc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *result = 0 ;
  
  result = (xmlChar *)(xmlChar *)xmlStringTextNoenc;
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlStringComment_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *result = 0 ;
  
  result = (xmlChar *)(xmlChar *)xmlStringComment;
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlIsLetter(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlIsLetter.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlIsLetter" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlIsLetter(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCreateFileParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlParserCtxtPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCreateFileParserCtxt.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCreateFileParserCtxt" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (xmlParserCtxtPtr)xmlCreateFileParserCtxt((char const *)arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCreateURLParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlParserCtxtPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCreateURLParserCtxt.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCreateURLParserCtxt" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlCreateURLParserCtxt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlParserCtxtPtr)xmlCreateURLParserCtxt((char const *)arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  // free(arg1);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCreateMemoryParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlParserCtxtPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCreateMemoryParserCtxt.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCreateMemoryParserCtxt" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlCreateMemoryParserCtxt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlParserCtxtPtr)xmlCreateMemoryParserCtxt((char const *)arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  // free(arg1);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCreateEntityParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlParserCtxtPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCreateEntityParserCtxt.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCreateEntityParserCtxt" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCreateEntityParserCtxt" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlCreateEntityParserCtxt" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlParserCtxtPtr)xmlCreateEntityParserCtxt((unsigned char const *)arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCtxtErrMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCtxtErrMemory.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCtxtErrMemory" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlCtxtErrMemory(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSwitchEncoding(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlCharEncoding arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSwitchEncoding.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSwitchEncoding" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlSwitchEncoding" "', argument " "2"" of type '" "xmlCharEncoding""'");
  } 
  arg2 = static_cast< xmlCharEncoding >(val2);result = (int)xmlSwitchEncoding(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSwitchEncodingName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSwitchEncodingName.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSwitchEncodingName" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSwitchEncodingName" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (int)xmlSwitchEncodingName(arg1,(char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSwitchToEncoding(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlCharEncodingHandlerPtr arg2 = (xmlCharEncodingHandlerPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSwitchToEncoding.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSwitchToEncoding" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSwitchToEncoding" "', argument " "2"" of type '" "xmlCharEncodingHandlerPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlCharEncodingHandlerPtr >(argp2);result = (int)xmlSwitchToEncoding(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSwitchInputEncoding(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlParserInputPtr arg2 = (xmlParserInputPtr) 0 ;
  xmlCharEncodingHandlerPtr arg3 = (xmlCharEncodingHandlerPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSwitchInputEncoding.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSwitchInputEncoding" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSwitchInputEncoding" "', argument " "2"" of type '" "xmlParserInputPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlParserInputPtr >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlCharEncodingHandler, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSwitchInputEncoding" "', argument " "3"" of type '" "xmlCharEncodingHandlerPtr""'"); 
  }
  arg3 = reinterpret_cast< xmlCharEncodingHandlerPtr >(argp3);result = (int)xmlSwitchInputEncoding(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewStringInputStream(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlParserInputPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewStringInputStream.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewStringInputStream" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewStringInputStream" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlParserInputPtr)xmlNewStringInputStream(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInput, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewEntityInputStream(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlEntityPtr arg2 = (xmlEntityPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlParserInputPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewEntityInputStream.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewEntityInputStream" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlEntity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlNewEntityInputStream', argument 2 of type 'xmlEntityPtr'"); 
  }
  arg2 = (xmlEntityPtr) arg20;result = (xmlParserInputPtr)xmlNewEntityInputStream(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInput, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlPushInput(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlParserInputPtr arg2 = (xmlParserInputPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlPushInput.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlPushInput" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlPushInput" "', argument " "2"" of type '" "xmlParserInputPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlParserInputPtr >(argp2);result = (int)xmlPushInput(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlPopInput(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlPopInput.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlPopInput" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlChar)xmlPopInput(arg1);
  jsresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeInputStream(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserInputPtr arg1 = (xmlParserInputPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeInputStream.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeInputStream" "', argument " "1"" of type '" "xmlParserInputPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserInputPtr >(argp1);xmlFreeInputStream(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewInputFromFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlParserInputPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewInputFromFile.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewInputFromFile" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewInputFromFile" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (xmlParserInputPtr)xmlNewInputFromFile(arg1,(char const *)arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInput, 0 |  0 );
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewInputStream(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlParserInputPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewInputStream.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewInputStream" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlParserInputPtr)xmlNewInputStream(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInput, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSplitQName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar **arg3 = (xmlChar **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSplitQName.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSplitQName" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSplitQName" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSplitQName" "', argument " "3"" of type '" "xmlChar **""'"); 
  }
  arg3 = reinterpret_cast< xmlChar ** >(argp3);result = (xmlChar *)xmlSplitQName(arg1,(unsigned char const *)arg2,arg3);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseName.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseName" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlChar *)xmlParseName(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseNmtoken(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseNmtoken.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseNmtoken" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlChar *)xmlParseNmtoken(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseEntityValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseEntityValue.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseEntityValue" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParseEntityValue" "', argument " "2"" of type '" "xmlChar **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);result = (xmlChar *)xmlParseEntityValue(arg1,arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseAttValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseAttValue.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseAttValue" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlChar *)xmlParseAttValue(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseSystemLiteral(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseSystemLiteral.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseSystemLiteral" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlChar *)xmlParseSystemLiteral(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParsePubidLiteral(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParsePubidLiteral.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParsePubidLiteral" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlChar *)xmlParsePubidLiteral(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseCharData(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseCharData.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseCharData" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlParseCharData" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);xmlParseCharData(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseExternalID(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseExternalID.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseExternalID" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParseExternalID" "', argument " "2"" of type '" "xmlChar **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlParseExternalID" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlChar *)xmlParseExternalID(arg1,arg2,arg3);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseComment(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseComment.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseComment" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlParseComment(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParsePITarget(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParsePITarget.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParsePITarget" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlChar *)xmlParsePITarget(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParsePI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParsePI.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParsePI" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlParsePI(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseNotationDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseNotationDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseNotationDecl" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlParseNotationDecl(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseEntityDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseEntityDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseEntityDecl" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlParseEntityDecl(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseDefaultDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseDefaultDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseDefaultDecl" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParseDefaultDecl" "', argument " "2"" of type '" "xmlChar **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);result = (int)xmlParseDefaultDecl(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseNotationType(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlEnumerationPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseNotationType.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseNotationType" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlEnumerationPtr)xmlParseNotationType(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlEnumeration, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseEnumerationType(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlEnumerationPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseEnumerationType.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseEnumerationType" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlEnumerationPtr)xmlParseEnumerationType(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlEnumeration, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseEnumeratedType(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlEnumerationPtr *arg2 = (xmlEnumerationPtr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseEnumeratedType.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseEnumeratedType" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p__xmlEnumeration, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParseEnumeratedType" "', argument " "2"" of type '" "xmlEnumerationPtr *""'"); 
  }
  arg2 = reinterpret_cast< xmlEnumerationPtr * >(argp2);result = (int)xmlParseEnumeratedType(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseAttributeType(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlEnumerationPtr *arg2 = (xmlEnumerationPtr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseAttributeType.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseAttributeType" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p__xmlEnumeration, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParseAttributeType" "', argument " "2"" of type '" "xmlEnumerationPtr *""'"); 
  }
  arg2 = reinterpret_cast< xmlEnumerationPtr * >(argp2);result = (int)xmlParseAttributeType(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseAttributeListDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseAttributeListDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseAttributeListDecl" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlParseAttributeListDecl(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseElementMixedContentDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlElementContentPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseElementMixedContentDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseElementMixedContentDecl" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlParseElementMixedContentDecl" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlElementContentPtr)xmlParseElementMixedContentDecl(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlElementContent, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseElementChildrenContentDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlElementContentPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseElementChildrenContentDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseElementChildrenContentDecl" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlParseElementChildrenContentDecl" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlElementContentPtr)xmlParseElementChildrenContentDecl(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlElementContent, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseElementContentDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlElementContentPtr *arg3 = (xmlElementContentPtr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseElementContentDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseElementContentDecl" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParseElementContentDecl" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p__xmlElementContent, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlParseElementContentDecl" "', argument " "3"" of type '" "xmlElementContentPtr *""'"); 
  }
  arg3 = reinterpret_cast< xmlElementContentPtr * >(argp3);result = (int)xmlParseElementContentDecl(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseElementDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseElementDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseElementDecl" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (int)xmlParseElementDecl(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseMarkupDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseMarkupDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseMarkupDecl" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlParseMarkupDecl(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseCharRef(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseCharRef.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseCharRef" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (int)xmlParseCharRef(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseEntityRef(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlEntityPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseEntityRef.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseEntityRef" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlEntityPtr)xmlParseEntityRef(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlEntity);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseReference(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseReference.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseReference" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlParseReference(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParsePEReference(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParsePEReference.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParsePEReference" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlParsePEReference(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseDocTypeDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseDocTypeDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseDocTypeDecl" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlParseDocTypeDecl(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseAttribute(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseAttribute.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseAttribute" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParseAttribute" "', argument " "2"" of type '" "xmlChar **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);result = (xmlChar *)xmlParseAttribute(arg1,arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseStartTag(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseStartTag.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseStartTag" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlChar *)xmlParseStartTag(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseEndTag(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseEndTag.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseEndTag" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlParseEndTag(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseCDSect(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseCDSect.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseCDSect" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlParseCDSect(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseContent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseContent.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseContent" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlParseContent(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseElement" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlParseElement(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseVersionNum(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseVersionNum.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseVersionNum" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlChar *)xmlParseVersionNum(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseVersionInfo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseVersionInfo.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseVersionInfo" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlChar *)xmlParseVersionInfo(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseEncName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseEncName.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseEncName" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlChar *)xmlParseEncName(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseEncodingDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseEncodingDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseEncodingDecl" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlChar *)xmlParseEncodingDecl(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseSDDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseSDDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseSDDecl" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (int)xmlParseSDDecl(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseXMLDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseXMLDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseXMLDecl" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlParseXMLDecl(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseTextDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseTextDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseTextDecl" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlParseTextDecl(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseMisc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseMisc.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseMisc" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlParseMisc(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseExternalSubset(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseExternalSubset.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseExternalSubset" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParseExternalSubset" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlParseExternalSubset" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }xmlParseExternalSubset(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_SUBSTITUTE_NONE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(0));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SUBSTITUTE_REF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SUBSTITUTE_PEREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SUBSTITUTE_BOTH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlStringDecodeEntities(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  xmlChar arg4 ;
  xmlChar arg5 ;
  xmlChar arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned char val4 ;
  int ecode4 = 0 ;
  unsigned char val5 ;
  int ecode5 = 0 ;
  unsigned char val6 ;
  int ecode6 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStringDecodeEntities.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStringDecodeEntities" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStringDecodeEntities" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlStringDecodeEntities" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);ecode4 = SWIG_AsVal_unsigned_SS_char(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlStringDecodeEntities" "', argument " "4"" of type '" "xmlChar""'");
  } 
  arg4 = static_cast< xmlChar >(val4);ecode5 = SWIG_AsVal_unsigned_SS_char(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlStringDecodeEntities" "', argument " "5"" of type '" "xmlChar""'");
  } 
  arg5 = static_cast< xmlChar >(val5);ecode6 = SWIG_AsVal_unsigned_SS_char(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xmlStringDecodeEntities" "', argument " "6"" of type '" "xmlChar""'");
  } 
  arg6 = static_cast< xmlChar >(val6);result = (xmlChar *)xmlStringDecodeEntities(arg1,(unsigned char const *)arg2,arg3,arg4,arg5,arg6);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStringLenDecodeEntities(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  int arg4 ;
  xmlChar arg5 ;
  xmlChar arg6 ;
  xmlChar arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned char val5 ;
  int ecode5 = 0 ;
  unsigned char val6 ;
  int ecode6 = 0 ;
  unsigned char val7 ;
  int ecode7 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 7 || args.Length() > 7) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStringLenDecodeEntities.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStringLenDecodeEntities" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStringLenDecodeEntities" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlStringLenDecodeEntities" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlStringLenDecodeEntities" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);ecode5 = SWIG_AsVal_unsigned_SS_char(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlStringLenDecodeEntities" "', argument " "5"" of type '" "xmlChar""'");
  } 
  arg5 = static_cast< xmlChar >(val5);ecode6 = SWIG_AsVal_unsigned_SS_char(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xmlStringLenDecodeEntities" "', argument " "6"" of type '" "xmlChar""'");
  } 
  arg6 = static_cast< xmlChar >(val6);ecode7 = SWIG_AsVal_unsigned_SS_char(args[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "xmlStringLenDecodeEntities" "', argument " "7"" of type '" "xmlChar""'");
  } 
  arg7 = static_cast< xmlChar >(val7);result = (xmlChar *)xmlStringLenDecodeEntities(arg1,(unsigned char const *)arg2,arg3,arg4,arg5,arg6,arg7);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_nodePush(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_nodePush.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nodePush" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'nodePush', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (int)nodePush(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_nodePop(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_nodePop.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nodePop" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlNodePtr)nodePop(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_inputPush(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlParserInputPtr arg2 = (xmlParserInputPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_inputPush.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "inputPush" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "inputPush" "', argument " "2"" of type '" "xmlParserInputPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlParserInputPtr >(argp2);result = (int)inputPush(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_inputPop(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlParserInputPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_inputPop.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "inputPop" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlParserInputPtr)inputPop(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInput, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_namePop(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_namePop.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "namePop" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (xmlChar *)namePop(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_namePush(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_namePush.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "namePush" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "namePush" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)namePush(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSkipBlankChars(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSkipBlankChars.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSkipBlankChars" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);result = (int)xmlSkipBlankChars(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStringCurrentChar(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int *arg3 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStringCurrentChar.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStringCurrentChar" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStringCurrentChar" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlStringCurrentChar" "', argument " "3"" of type '" "int *""'"); 
  }
  arg3 = reinterpret_cast< int * >(argp3);result = (int)xmlStringCurrentChar(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserHandlePEReference(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserHandlePEReference.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserHandlePEReference" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlParserHandlePEReference(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCheckLanguageID(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCheckLanguageID.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCheckLanguageID" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (int)xmlCheckLanguageID((unsigned char const *)arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCurrentChar(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  int *arg2 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCurrentChar.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCurrentChar" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCurrentChar" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);result = (int)xmlCurrentChar(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyCharMultiByte(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyCharMultiByte.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCopyCharMultiByte" "', argument " "1"" of type '" "xmlChar *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlCopyCharMultiByte" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlCopyCharMultiByte(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCopyChar(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCopyChar.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlCopyChar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlCopyChar" "', argument " "2"" of type '" "xmlChar *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlCopyChar" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlCopyChar(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNextChar(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNextChar.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNextChar" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);xmlNextChar(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParserInputShrink(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserInputPtr arg1 = (xmlParserInputPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserInputShrink.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserInput, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserInputShrink" "', argument " "1"" of type '" "xmlParserInputPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserInputPtr >(argp1);xmlParserInputShrink(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_PATTERN_DEFAULT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PATTERN_DEFAULT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PATTERN_XPATH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PATTERN_XPATH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PATTERN_XSSEL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PATTERN_XSSEL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PATTERN_XSFIELD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PATTERN_XSFIELD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlFreePattern(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlPatternPtr arg1 = (xmlPatternPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreePattern.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlPattern, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreePattern" "', argument " "1"" of type '" "xmlPatternPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlPatternPtr >(argp1);xmlFreePattern(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreePatternList(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlPatternPtr arg1 = (xmlPatternPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreePatternList.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlPattern, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreePatternList" "', argument " "1"" of type '" "xmlPatternPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlPatternPtr >(argp1);xmlFreePatternList(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlPatterncompile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlDict *arg2 = (xmlDict *) 0 ;
  int arg3 ;
  xmlChar **arg4 = (xmlChar **) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  xmlPatternPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlPatterncompile.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlPatterncompile" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlDict, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlPatterncompile" "', argument " "2"" of type '" "xmlDict *""'"); 
  }
  arg2 = reinterpret_cast< xmlDict * >(argp2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlPatterncompile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlPatterncompile" "', argument " "4"" of type '" "xmlChar const **""'"); 
  }
  arg4 = reinterpret_cast< xmlChar ** >(argp4);result = (xmlPatternPtr)xmlPatterncompile((unsigned char const *)arg1,arg2,arg3,(unsigned char const **)arg4);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlPattern, 0 |  0 );
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlPatternCompileSafe(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlDict *arg2 = (xmlDict *) 0 ;
  int arg3 ;
  xmlChar **arg4 = (xmlChar **) 0 ;
  xmlPatternPtr *arg5 = (xmlPatternPtr *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlPatternCompileSafe.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlPatternCompileSafe" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlDict, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlPatternCompileSafe" "', argument " "2"" of type '" "xmlDict *""'"); 
  }
  arg2 = reinterpret_cast< xmlDict * >(argp2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlPatternCompileSafe" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlPatternCompileSafe" "', argument " "4"" of type '" "xmlChar const **""'"); 
  }
  arg4 = reinterpret_cast< xmlChar ** >(argp4);res5 = SWIG_ConvertPtr(args[4], &argp5,SWIGTYPE_p_p__xmlPattern, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlPatternCompileSafe" "', argument " "5"" of type '" "xmlPatternPtr *""'"); 
  }
  arg5 = reinterpret_cast< xmlPatternPtr * >(argp5);result = (int)xmlPatternCompileSafe((unsigned char const *)arg1,arg2,arg3,(unsigned char const **)arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlPatternMatch(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlPatternPtr arg1 = (xmlPatternPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlPatternMatch.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlPattern, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlPatternMatch" "', argument " "1"" of type '" "xmlPatternPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlPatternPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlPatternMatch', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (int)xmlPatternMatch(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlPatternStreamable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlPatternPtr arg1 = (xmlPatternPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlPatternStreamable.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlPattern, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlPatternStreamable" "', argument " "1"" of type '" "xmlPatternPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlPatternPtr >(argp1);result = (int)xmlPatternStreamable(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlPatternMaxDepth(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlPatternPtr arg1 = (xmlPatternPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlPatternMaxDepth.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlPattern, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlPatternMaxDepth" "', argument " "1"" of type '" "xmlPatternPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlPatternPtr >(argp1);result = (int)xmlPatternMaxDepth(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlPatternMinDepth(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlPatternPtr arg1 = (xmlPatternPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlPatternMinDepth.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlPattern, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlPatternMinDepth" "', argument " "1"" of type '" "xmlPatternPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlPatternPtr >(argp1);result = (int)xmlPatternMinDepth(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlPatternFromRoot(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlPatternPtr arg1 = (xmlPatternPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlPatternFromRoot.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlPattern, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlPatternFromRoot" "', argument " "1"" of type '" "xmlPatternPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlPatternPtr >(argp1);result = (int)xmlPatternFromRoot(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlPatternGetStreamCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlPatternPtr arg1 = (xmlPatternPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlStreamCtxtPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlPatternGetStreamCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlPattern, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlPatternGetStreamCtxt" "', argument " "1"" of type '" "xmlPatternPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlPatternPtr >(argp1);result = (xmlStreamCtxtPtr)xmlPatternGetStreamCtxt(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlStreamCtxt, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeStreamCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlStreamCtxtPtr arg1 = (xmlStreamCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeStreamCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlStreamCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeStreamCtxt" "', argument " "1"" of type '" "xmlStreamCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlStreamCtxtPtr >(argp1);xmlFreeStreamCtxt(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStreamPushNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlStreamCtxtPtr arg1 = (xmlStreamCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStreamPushNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlStreamCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStreamPushNode" "', argument " "1"" of type '" "xmlStreamCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlStreamCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStreamPushNode" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlStreamPushNode" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlStreamPushNode" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (int)xmlStreamPushNode(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStreamPush(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlStreamCtxtPtr arg1 = (xmlStreamCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStreamPush.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlStreamCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStreamPush" "', argument " "1"" of type '" "xmlStreamCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlStreamCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStreamPush" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlStreamPush" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (int)xmlStreamPush(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStreamPushAttr(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlStreamCtxtPtr arg1 = (xmlStreamCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStreamPushAttr.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlStreamCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStreamPushAttr" "', argument " "1"" of type '" "xmlStreamCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlStreamCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlStreamPushAttr" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlStreamPushAttr" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (int)xmlStreamPushAttr(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStreamPop(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlStreamCtxtPtr arg1 = (xmlStreamCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStreamPop.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlStreamCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStreamPop" "', argument " "1"" of type '" "xmlStreamCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlStreamCtxtPtr >(argp1);result = (int)xmlStreamPop(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlStreamWantsAnyNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlStreamCtxtPtr arg1 = (xmlStreamCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlStreamWantsAnyNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlStreamCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlStreamWantsAnyNode" "', argument " "1"" of type '" "xmlStreamCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlStreamCtxtPtr >(argp1);result = (int)xmlStreamWantsAnyNode(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_RELAXNG_OK_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_OK));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_MEMORY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_MEMORY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_TYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_TYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_TYPEVAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_TYPEVAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_DUPID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_DUPID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_TYPECMP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_TYPECMP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_NOSTATE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_NOSTATE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_NODEFINE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_NODEFINE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_LISTEXTRA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_LISTEXTRA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_LISTEMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_LISTEMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_INTERNODATA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_INTERNODATA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_INTERSEQ_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_INTERSEQ));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_INTEREXTRA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_INTEREXTRA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_ELEMNAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_ELEMNAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_ATTRNAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_ATTRNAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_ELEMNONS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_ELEMNONS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_ATTRNONS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_ATTRNONS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_ELEMWRONGNS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_ELEMWRONGNS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_ATTRWRONGNS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_ATTRWRONGNS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_ELEMEXTRANS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_ELEMEXTRANS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_ATTREXTRANS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_ATTREXTRANS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_ELEMNOTEMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_ELEMNOTEMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_NOELEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_NOELEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_NOTELEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_NOTELEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_ATTRVALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_ATTRVALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_CONTENTVALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_CONTENTVALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_EXTRACONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_EXTRACONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_INVALIDATTR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_INVALIDATTR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_DATAELEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_DATAELEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_VALELEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_VALELEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_LISTELEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_LISTELEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_DATATYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_DATATYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_LIST_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_LIST));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_NOGRAMMAR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_NOGRAMMAR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_EXTRADATA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_EXTRADATA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_LACKDATA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_LACKDATA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_INTERNAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_INTERNAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_ELEMWRONG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_ELEMWRONG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNG_ERR_TEXTWRONG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNG_ERR_TEXTWRONG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNGP_NONE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNGP_NONE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNGP_FREE_DOC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNGP_FREE_DOC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_RELAXNGP_CRNG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_RELAXNGP_CRNG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlRelaxNGInitTypes(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGInitTypes.");
  
  result = (int)xmlRelaxNGInitTypes();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGCleanupTypes(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGCleanupTypes.");
  
  xmlRelaxNGCleanupTypes();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGNewParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlRelaxNGParserCtxtPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGNewParserCtxt.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGNewParserCtxt" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (xmlRelaxNGParserCtxtPtr)xmlRelaxNGNewParserCtxt((char const *)arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlRelaxNGParserCtxt, 0 |  0 );
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGNewMemParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlRelaxNGParserCtxtPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGNewMemParserCtxt.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGNewMemParserCtxt" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlRelaxNGNewMemParserCtxt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlRelaxNGParserCtxtPtr)xmlRelaxNGNewMemParserCtxt((char const *)arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlRelaxNGParserCtxt, 0 |  0 );
  // free(arg1);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGNewDocParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlRelaxNGParserCtxtPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGNewDocParserCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlRelaxNGNewDocParserCtxt', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;result = (xmlRelaxNGParserCtxtPtr)xmlRelaxNGNewDocParserCtxt(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlRelaxNGParserCtxt, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxParserSetFlag(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRelaxNGParserCtxtPtr arg1 = (xmlRelaxNGParserCtxtPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxParserSetFlag.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRelaxNGParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxParserSetFlag" "', argument " "1"" of type '" "xmlRelaxNGParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRelaxNGParserCtxtPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlRelaxParserSetFlag" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlRelaxParserSetFlag(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGFreeParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRelaxNGParserCtxtPtr arg1 = (xmlRelaxNGParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGFreeParserCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRelaxNGParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGFreeParserCtxt" "', argument " "1"" of type '" "xmlRelaxNGParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRelaxNGParserCtxtPtr >(argp1);xmlRelaxNGFreeParserCtxt(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGSetParserErrors(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRelaxNGParserCtxtPtr arg1 = (xmlRelaxNGParserCtxtPtr) 0 ;
  xmlRelaxNGValidityErrorFunc arg2 = (xmlRelaxNGValidityErrorFunc) 0 ;
  xmlRelaxNGValidityWarningFunc arg3 = (xmlRelaxNGValidityWarningFunc) 0 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGSetParserErrors.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRelaxNGParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGSetParserErrors" "', argument " "1"" of type '" "xmlRelaxNGParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRelaxNGParserCtxtPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRelaxNGSetParserErrors" "', argument " "2"" of type '" "xmlRelaxNGValidityErrorFunc""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRelaxNGSetParserErrors" "', argument " "3"" of type '" "xmlRelaxNGValidityWarningFunc""'"); 
      }
    }
  }
  arg4 = getSwigCObjectPtr(args[3]);xmlRelaxNGSetParserErrors(arg1,arg2,arg3,arg4);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGGetParserErrors(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRelaxNGParserCtxtPtr arg1 = (xmlRelaxNGParserCtxtPtr) 0 ;
  xmlRelaxNGValidityErrorFunc *arg2 = (xmlRelaxNGValidityErrorFunc *) 0 ;
  xmlRelaxNGValidityWarningFunc *arg3 = (xmlRelaxNGValidityWarningFunc *) 0 ;
  void **arg4 = (void **) 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 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGGetParserErrors.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRelaxNGParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGGetParserErrors" "', argument " "1"" of type '" "xmlRelaxNGParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRelaxNGParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_f_p_void_p_q_const__char_v_______void, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlRelaxNGGetParserErrors" "', argument " "2"" of type '" "xmlRelaxNGValidityErrorFunc *""'"); 
  }
  arg2 = reinterpret_cast< xmlRelaxNGValidityErrorFunc * >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p_f_p_void_p_q_const__char_v_______void, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlRelaxNGGetParserErrors" "', argument " "3"" of type '" "xmlRelaxNGValidityWarningFunc *""'"); 
  }
  arg3 = reinterpret_cast< xmlRelaxNGValidityWarningFunc * >(argp3);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_p_void, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlRelaxNGGetParserErrors" "', argument " "4"" of type '" "void **""'"); 
  }
  arg4 = reinterpret_cast< void ** >(argp4);result = (int)xmlRelaxNGGetParserErrors(arg1,arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGSetParserStructuredErrors(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRelaxNGParserCtxtPtr arg1 = (xmlRelaxNGParserCtxtPtr) 0 ;
  xmlStructuredErrorFunc arg2 = (xmlStructuredErrorFunc) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGSetParserStructuredErrors.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRelaxNGParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGSetParserStructuredErrors" "', argument " "1"" of type '" "xmlRelaxNGParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRelaxNGParserCtxtPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const___xmlError__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRelaxNGSetParserStructuredErrors" "', argument " "2"" of type '" "xmlStructuredErrorFunc""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);xmlRelaxNGSetParserStructuredErrors(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGParse(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRelaxNGParserCtxtPtr arg1 = (xmlRelaxNGParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlRelaxNGPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGParse.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRelaxNGParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGParse" "', argument " "1"" of type '" "xmlRelaxNGParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRelaxNGParserCtxtPtr >(argp1);result = (xmlRelaxNGPtr)xmlRelaxNGParse(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlRelaxNG, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGFree(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRelaxNGPtr arg1 = (xmlRelaxNGPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGFree.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRelaxNG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGFree" "', argument " "1"" of type '" "xmlRelaxNGPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRelaxNGPtr >(argp1);xmlRelaxNGFree(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGDump(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  xmlRelaxNGPtr arg2 = (xmlRelaxNGPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGDump.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGDump" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlRelaxNG, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlRelaxNGDump" "', argument " "2"" of type '" "xmlRelaxNGPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlRelaxNGPtr >(argp2);xmlRelaxNGDump(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGDumpTree(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  xmlRelaxNGPtr arg2 = (xmlRelaxNGPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGDumpTree.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGDumpTree" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlRelaxNG, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlRelaxNGDumpTree" "', argument " "2"" of type '" "xmlRelaxNGPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlRelaxNGPtr >(argp2);xmlRelaxNGDumpTree(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGSetValidErrors(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRelaxNGValidCtxtPtr arg1 = (xmlRelaxNGValidCtxtPtr) 0 ;
  xmlRelaxNGValidityErrorFunc arg2 = (xmlRelaxNGValidityErrorFunc) 0 ;
  xmlRelaxNGValidityWarningFunc arg3 = (xmlRelaxNGValidityWarningFunc) 0 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGSetValidErrors.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRelaxNGValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGSetValidErrors" "', argument " "1"" of type '" "xmlRelaxNGValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRelaxNGValidCtxtPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRelaxNGSetValidErrors" "', argument " "2"" of type '" "xmlRelaxNGValidityErrorFunc""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRelaxNGSetValidErrors" "', argument " "3"" of type '" "xmlRelaxNGValidityWarningFunc""'"); 
      }
    }
  }
  arg4 = getSwigCObjectPtr(args[3]);xmlRelaxNGSetValidErrors(arg1,arg2,arg3,arg4);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGGetValidErrors(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRelaxNGValidCtxtPtr arg1 = (xmlRelaxNGValidCtxtPtr) 0 ;
  xmlRelaxNGValidityErrorFunc *arg2 = (xmlRelaxNGValidityErrorFunc *) 0 ;
  xmlRelaxNGValidityWarningFunc *arg3 = (xmlRelaxNGValidityWarningFunc *) 0 ;
  void **arg4 = (void **) 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 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGGetValidErrors.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRelaxNGValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGGetValidErrors" "', argument " "1"" of type '" "xmlRelaxNGValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRelaxNGValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_f_p_void_p_q_const__char_v_______void, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlRelaxNGGetValidErrors" "', argument " "2"" of type '" "xmlRelaxNGValidityErrorFunc *""'"); 
  }
  arg2 = reinterpret_cast< xmlRelaxNGValidityErrorFunc * >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p_f_p_void_p_q_const__char_v_______void, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlRelaxNGGetValidErrors" "', argument " "3"" of type '" "xmlRelaxNGValidityWarningFunc *""'"); 
  }
  arg3 = reinterpret_cast< xmlRelaxNGValidityWarningFunc * >(argp3);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_p_void, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlRelaxNGGetValidErrors" "', argument " "4"" of type '" "void **""'"); 
  }
  arg4 = reinterpret_cast< void ** >(argp4);result = (int)xmlRelaxNGGetValidErrors(arg1,arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGSetValidStructuredErrors(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRelaxNGValidCtxtPtr arg1 = (xmlRelaxNGValidCtxtPtr) 0 ;
  xmlStructuredErrorFunc arg2 = (xmlStructuredErrorFunc) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGSetValidStructuredErrors.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRelaxNGValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGSetValidStructuredErrors" "', argument " "1"" of type '" "xmlRelaxNGValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRelaxNGValidCtxtPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const___xmlError__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRelaxNGSetValidStructuredErrors" "', argument " "2"" of type '" "xmlStructuredErrorFunc""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);xmlRelaxNGSetValidStructuredErrors(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGNewValidCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRelaxNGPtr arg1 = (xmlRelaxNGPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlRelaxNGValidCtxtPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGNewValidCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRelaxNG, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGNewValidCtxt" "', argument " "1"" of type '" "xmlRelaxNGPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRelaxNGPtr >(argp1);result = (xmlRelaxNGValidCtxtPtr)xmlRelaxNGNewValidCtxt(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlRelaxNGValidCtxt, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGFreeValidCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRelaxNGValidCtxtPtr arg1 = (xmlRelaxNGValidCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGFreeValidCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRelaxNGValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGFreeValidCtxt" "', argument " "1"" of type '" "xmlRelaxNGValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRelaxNGValidCtxtPtr >(argp1);xmlRelaxNGFreeValidCtxt(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGValidateDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRelaxNGValidCtxtPtr arg1 = (xmlRelaxNGValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGValidateDoc.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRelaxNGValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGValidateDoc" "', argument " "1"" of type '" "xmlRelaxNGValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRelaxNGValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlRelaxNGValidateDoc', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;result = (int)xmlRelaxNGValidateDoc(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGValidatePushElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRelaxNGValidCtxtPtr arg1 = (xmlRelaxNGValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGValidatePushElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRelaxNGValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGValidatePushElement" "', argument " "1"" of type '" "xmlRelaxNGValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRelaxNGValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlRelaxNGValidatePushElement', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlRelaxNGValidatePushElement', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);result = (int)xmlRelaxNGValidatePushElement(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGValidatePushCData(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRelaxNGValidCtxtPtr arg1 = (xmlRelaxNGValidCtxtPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGValidatePushCData.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRelaxNGValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGValidatePushCData" "', argument " "1"" of type '" "xmlRelaxNGValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRelaxNGValidCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlRelaxNGValidatePushCData" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlRelaxNGValidatePushCData" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlRelaxNGValidatePushCData(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGValidatePopElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRelaxNGValidCtxtPtr arg1 = (xmlRelaxNGValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGValidatePopElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRelaxNGValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGValidatePopElement" "', argument " "1"" of type '" "xmlRelaxNGValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRelaxNGValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlRelaxNGValidatePopElement', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlRelaxNGValidatePopElement', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);result = (int)xmlRelaxNGValidatePopElement(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlRelaxNGValidateFullElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRelaxNGValidCtxtPtr arg1 = (xmlRelaxNGValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlRelaxNGValidateFullElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlRelaxNGValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlRelaxNGValidateFullElement" "', argument " "1"" of type '" "xmlRelaxNGValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlRelaxNGValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlRelaxNGValidateFullElement', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlRelaxNGValidateFullElement', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);result = (int)xmlRelaxNGValidateFullElement(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap__xmlURI_scheme_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_scheme_set" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlURI_scheme_set" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }delete[] arg1->scheme;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->scheme = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->scheme = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlURI_scheme_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_scheme_get" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);result = (char *) ((arg1)->scheme);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlURI_opaque_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_opaque_set" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlURI_opaque_set" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }delete[] arg1->opaque;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->opaque = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->opaque = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlURI_opaque_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_opaque_get" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);result = (char *) ((arg1)->opaque);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlURI_authority_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_authority_set" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlURI_authority_set" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }delete[] arg1->authority;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->authority = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->authority = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlURI_authority_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_authority_get" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);result = (char *) ((arg1)->authority);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlURI_server_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_server_set" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlURI_server_set" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }delete[] arg1->server;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->server = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->server = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlURI_server_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_server_get" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);result = (char *) ((arg1)->server);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlURI_user_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_user_set" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlURI_user_set" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }delete[] arg1->user;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->user = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->user = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlURI_user_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_user_get" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);result = (char *) ((arg1)->user);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlURI_port_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_port_set" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlURI_port_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->port = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlURI_port_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_port_get" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);result = (int) ((arg1)->port);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlURI_path_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_path_set" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlURI_path_set" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }delete[] arg1->path;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->path = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->path = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlURI_path_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_path_get" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);result = (char *) ((arg1)->path);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlURI_query_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_query_set" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlURI_query_set" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }delete[] arg1->query;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->query = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->query = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlURI_query_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_query_get" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);result = (char *) ((arg1)->query);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlURI_fragment_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_fragment_set" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlURI_fragment_set" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }delete[] arg1->fragment;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->fragment = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->fragment = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlURI_fragment_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_fragment_get" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);result = (char *) ((arg1)->fragment);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlURI_cleanup_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_cleanup_set" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlURI_cleanup_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->cleanup = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlURI_cleanup_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_cleanup_get" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);result = (int) ((arg1)->cleanup);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlURI_query_raw_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_query_raw_set" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlURI_query_raw_set" "', argument " "2"" of type '" "char *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }delete[] arg1->query_raw;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->query_raw = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->query_raw = 0;
  }
  
  // free(arg2);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlURI_query_raw_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlURI *arg1 = (_xmlURI *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlURI_query_raw_get" "', argument " "1"" of type '" "_xmlURI *""'"); 
  }
  arg1 = reinterpret_cast< _xmlURI * >(argp1);result = (char *) ((arg1)->query_raw);
  jsresult = SWIG_FromCharPtr((const char *)result);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlURI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlURI *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlURI.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlURI.");
  result = (_xmlURI *)new _xmlURI();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlURI, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlURI(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlURI * arg1 = (_xmlURI *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap_xmlCreateURI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlURIPtr result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCreateURI.");
  
  result = (xmlURIPtr)xmlCreateURI();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlURI, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBuildURISafe(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar **arg3 = (xmlChar **) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBuildURISafe.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBuildURISafe" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlBuildURISafe" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlBuildURISafe" "', argument " "3"" of type '" "xmlChar **""'"); 
  }
  arg3 = reinterpret_cast< xmlChar ** >(argp3);result = (int)xmlBuildURISafe((unsigned char const *)arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBuildURI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBuildURI.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBuildURI" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlBuildURI" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlBuildURI((unsigned char const *)arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBuildRelativeURISafe(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar **arg3 = (xmlChar **) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBuildRelativeURISafe.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBuildRelativeURISafe" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlBuildRelativeURISafe" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlBuildRelativeURISafe" "', argument " "3"" of type '" "xmlChar **""'"); 
  }
  arg3 = reinterpret_cast< xmlChar ** >(argp3);result = (int)xmlBuildRelativeURISafe((unsigned char const *)arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlBuildRelativeURI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlBuildRelativeURI.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlBuildRelativeURI" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlBuildRelativeURI" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlBuildRelativeURI((unsigned char const *)arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseURI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlURIPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseURI.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseURI" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (xmlURIPtr)xmlParseURI((char const *)arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlURI, 0 |  0 );
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseURISafe(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  xmlURIPtr *arg2 = (xmlURIPtr *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseURISafe.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseURISafe" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParseURISafe" "', argument " "2"" of type '" "xmlURIPtr *""'"); 
  }
  arg2 = reinterpret_cast< xmlURIPtr * >(argp2);result = (int)xmlParseURISafe((char const *)arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  // free(arg1);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseURIRaw(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlURIPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseURIRaw.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseURIRaw" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlParseURIRaw" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlURIPtr)xmlParseURIRaw((char const *)arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlURI, 0 |  0 );
  // free(arg1);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseURIReference(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlURIPtr arg1 = (xmlURIPtr) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseURIReference.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseURIReference" "', argument " "1"" of type '" "xmlURIPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlURIPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlParseURIReference" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (int)xmlParseURIReference(arg1,(char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSaveUri(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlURIPtr arg1 = (xmlURIPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSaveUri.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSaveUri" "', argument " "1"" of type '" "xmlURIPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlURIPtr >(argp1);result = (xmlChar *)xmlSaveUri(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlPrintURI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  xmlURIPtr arg2 = (xmlURIPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlPrintURI.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlPrintURI" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlPrintURI" "', argument " "2"" of type '" "xmlURIPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlURIPtr >(argp2);xmlPrintURI(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlURIEscapeStr(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlURIEscapeStr.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlURIEscapeStr" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlURIEscapeStr" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlURIEscapeStr((unsigned char const *)arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlURIUnescapeString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  char *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlURIUnescapeString.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlURIUnescapeString" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlURIUnescapeString" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlURIUnescapeString" "', argument " "3"" of type '" "char *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }result = (char *)xmlURIUnescapeString((char const *)arg1,arg2,arg3);
  jsresult = SWIG_FromCharPtr((const char *)result);
  // free(arg1);
  
  // free(arg3);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNormalizeURIPath(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNormalizeURIPath.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNormalizeURIPath" "', argument " "1"" of type '" "char *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (int)xmlNormalizeURIPath(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlURIEscape(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlURIEscape.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlURIEscape" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlChar *)xmlURIEscape((unsigned char const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeURI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlURIPtr arg1 = (xmlURIPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeURI.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlURI, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeURI" "', argument " "1"" of type '" "xmlURIPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlURIPtr >(argp1);xmlFreeURI(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlCanonicPath(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCanonicPath.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlCanonicPath" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlChar *)xmlCanonicPath((unsigned char const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlPathToURI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlPathToURI.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlPathToURI" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlChar *)xmlPathToURI((unsigned char const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXIncludeProcess(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXIncludeProcess.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXIncludeProcess', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;result = (int)xmlXIncludeProcess(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXIncludeProcessFlags(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXIncludeProcessFlags.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXIncludeProcessFlags', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXIncludeProcessFlags" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlXIncludeProcessFlags(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXIncludeProcessFlagsData(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  int arg2 ;
  void *arg3 = (void *) 0 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXIncludeProcessFlagsData.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXIncludeProcessFlagsData', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXIncludeProcessFlagsData" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);arg3 = getSwigCObjectPtr(args[2]);result = (int)xmlXIncludeProcessFlagsData(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXIncludeProcessTreeFlagsData(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int arg2 ;
  void *arg3 = (void *) 0 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXIncludeProcessTreeFlagsData.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXIncludeProcessTreeFlagsData', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXIncludeProcessTreeFlagsData" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);arg3 = getSwigCObjectPtr(args[2]);result = (int)xmlXIncludeProcessTreeFlagsData(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXIncludeProcessTree(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXIncludeProcessTree.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXIncludeProcessTree', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);result = (int)xmlXIncludeProcessTree(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXIncludeProcessTreeFlags(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXIncludeProcessTreeFlags.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res1)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXIncludeProcessTreeFlags', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXIncludeProcessTreeFlags" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlXIncludeProcessTreeFlags(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXIncludeNewContext(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlXIncludeCtxtPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXIncludeNewContext.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXIncludeNewContext', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;result = (xmlXIncludeCtxtPtr)xmlXIncludeNewContext(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXIncludeCtxt, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXIncludeSetFlags(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXIncludeCtxtPtr arg1 = (xmlXIncludeCtxtPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXIncludeSetFlags.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXIncludeCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXIncludeSetFlags" "', argument " "1"" of type '" "xmlXIncludeCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXIncludeCtxtPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXIncludeSetFlags" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlXIncludeSetFlags(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXIncludeSetErrorHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXIncludeCtxtPtr arg1 = (xmlXIncludeCtxtPtr) 0 ;
  xmlStructuredErrorFunc arg2 = (xmlStructuredErrorFunc) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXIncludeSetErrorHandler.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXIncludeCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXIncludeSetErrorHandler" "', argument " "1"" of type '" "xmlXIncludeCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXIncludeCtxtPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const___xmlError__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlXIncludeSetErrorHandler" "', argument " "2"" of type '" "xmlStructuredErrorFunc""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);xmlXIncludeSetErrorHandler(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXIncludeGetLastError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXIncludeCtxtPtr arg1 = (xmlXIncludeCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXIncludeGetLastError.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXIncludeCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXIncludeGetLastError" "', argument " "1"" of type '" "xmlXIncludeCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXIncludeCtxtPtr >(argp1);result = (int)xmlXIncludeGetLastError(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXIncludeFreeContext(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXIncludeCtxtPtr arg1 = (xmlXIncludeCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXIncludeFreeContext.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXIncludeCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXIncludeFreeContext" "', argument " "1"" of type '" "xmlXIncludeCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXIncludeCtxtPtr >(argp1);xmlXIncludeFreeContext(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXIncludeProcessNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXIncludeCtxtPtr arg1 = (xmlXIncludeCtxtPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXIncludeProcessNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXIncludeCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXIncludeProcessNode" "', argument " "1"" of type '" "xmlXIncludeCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXIncludeCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXIncludeProcessNode', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (int)xmlXIncludeProcessNode(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XLINK_TYPE_NONE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XLINK_TYPE_NONE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XLINK_TYPE_SIMPLE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XLINK_TYPE_SIMPLE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XLINK_TYPE_EXTENDED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XLINK_TYPE_EXTENDED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XLINK_TYPE_EXTENDED_SET_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XLINK_TYPE_EXTENDED_SET));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XLINK_SHOW_NONE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XLINK_SHOW_NONE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XLINK_SHOW_NEW_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XLINK_SHOW_NEW));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XLINK_SHOW_EMBED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XLINK_SHOW_EMBED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XLINK_SHOW_REPLACE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XLINK_SHOW_REPLACE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XLINK_ACTUATE_NONE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XLINK_ACTUATE_NONE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XLINK_ACTUATE_AUTO_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XLINK_ACTUATE_AUTO));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XLINK_ACTUATE_ONREQUEST_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XLINK_ACTUATE_ONREQUEST));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xlinkHandler_simple_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xlinkHandler *arg1 = (_xlinkHandler *) 0 ;
  xlinkSimpleLinkFunk arg2 = (xlinkSimpleLinkFunk) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xlinkHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xlinkHandler_simple_set" "', argument " "1"" of type '" "_xlinkHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xlinkHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p__xmlNode_q_const__p_unsigned_char_q_const__p_unsigned_char_q_const__p_unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xlinkHandler_simple_set" "', argument " "2"" of type '" "xlinkSimpleLinkFunk""'"); 
      }
    }
  }
  if (arg1) (arg1)->simple = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xlinkHandler_simple_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xlinkHandler *arg1 = (_xlinkHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xlinkSimpleLinkFunk result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xlinkHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xlinkHandler_simple_get" "', argument " "1"" of type '" "_xlinkHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xlinkHandler * >(argp1);result = (xlinkSimpleLinkFunk) ((arg1)->simple);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p__xmlNode_q_const__p_unsigned_char_q_const__p_unsigned_char_q_const__p_unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xlinkHandler_extended_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xlinkHandler *arg1 = (_xlinkHandler *) 0 ;
  xlinkExtendedLinkFunk arg2 = (xlinkExtendedLinkFunk) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xlinkHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xlinkHandler_extended_set" "', argument " "1"" of type '" "_xlinkHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xlinkHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_p_enum_xlinkShow_p_enum_xlinkActuate_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xlinkHandler_extended_set" "', argument " "2"" of type '" "xlinkExtendedLinkFunk""'"); 
      }
    }
  }
  if (arg1) (arg1)->extended = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xlinkHandler_extended_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xlinkHandler *arg1 = (_xlinkHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xlinkExtendedLinkFunk result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xlinkHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xlinkHandler_extended_get" "', argument " "1"" of type '" "_xlinkHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xlinkHandler * >(argp1);result = (xlinkExtendedLinkFunk) ((arg1)->extended);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_p_enum_xlinkShow_p_enum_xlinkActuate_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xlinkHandler_set_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xlinkHandler *arg1 = (_xlinkHandler *) 0 ;
  xlinkExtendedLinkSetFunk arg2 = (xlinkExtendedLinkSetFunk) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xlinkHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xlinkHandler_set_set" "', argument " "1"" of type '" "_xlinkHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xlinkHandler * >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg2), SWIGTYPE_p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "_xlinkHandler_set_set" "', argument " "2"" of type '" "xlinkExtendedLinkSetFunk""'"); 
      }
    }
  }
  if (arg1) (arg1)->set = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xlinkHandler_set_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xlinkHandler *arg1 = (_xlinkHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xlinkExtendedLinkSetFunk result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xlinkHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xlinkHandler_set_get" "', argument " "1"" of type '" "_xlinkHandler *""'"); 
  }
  arg1 = reinterpret_cast< _xlinkHandler * >(argp1);result = (xlinkExtendedLinkSetFunk) ((arg1)->set);
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xlinkHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xlinkHandler *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xlinkHandler.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xlinkHandler.");
  result = (_xlinkHandler *)new _xlinkHandler();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xlinkHandler, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xlinkHandler(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xlinkHandler * arg1 = (_xlinkHandler *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap_xlinkGetDefaultDetect(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xlinkNodeDetectFunc result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xlinkGetDefaultDetect.");
  
  result = (xlinkNodeDetectFunc)xlinkGetDefaultDetect();
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p__xmlNode__void);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xlinkSetDefaultDetect(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xlinkNodeDetectFunc arg1 = (xlinkNodeDetectFunc) 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xlinkSetDefaultDetect.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p__xmlNode__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xlinkSetDefaultDetect" "', argument " "1"" of type '" "xlinkNodeDetectFunc""'"); 
      }
    }
  }
  xlinkSetDefaultDetect(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xlinkGetDefaultHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xlinkHandlerPtr result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xlinkGetDefaultHandler.");
  
  result = (xlinkHandlerPtr)xlinkGetDefaultHandler();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xlinkHandler, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xlinkSetDefaultHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xlinkHandlerPtr arg1 = (xlinkHandlerPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xlinkSetDefaultHandler.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xlinkHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xlinkSetDefaultHandler" "', argument " "1"" of type '" "xlinkHandlerPtr""'"); 
  }
  arg1 = reinterpret_cast< xlinkHandlerPtr >(argp1);xlinkSetDefaultHandler(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xlinkIsLink(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  xlinkType result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xlinkIsLink.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xlinkIsLink', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xlinkIsLink', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (xlinkType)xlinkIsLink(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_MODULE_LAZY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_MODULE_LAZY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_MODULE_LOCAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_MODULE_LOCAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlModuleOpen(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlModulePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlModuleOpen.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlModuleOpen" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlModuleOpen" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlModulePtr)xmlModuleOpen((char const *)arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlModule, 0 |  0 );
  // free(arg1);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlModuleSymbol(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlModulePtr arg1 = (xmlModulePtr) 0 ;
  char *arg2 = (char *) 0 ;
  void **arg3 = (void **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlModuleSymbol.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlModuleSymbol" "', argument " "1"" of type '" "xmlModulePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlModulePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlModuleSymbol" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p_void, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlModuleSymbol" "', argument " "3"" of type '" "void **""'"); 
  }
  arg3 = reinterpret_cast< void ** >(argp3);result = (int)xmlModuleSymbol(arg1,(char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlModuleClose(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlModulePtr arg1 = (xmlModulePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlModuleClose.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlModuleClose" "', argument " "1"" of type '" "xmlModulePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlModulePtr >(argp1);result = (int)xmlModuleClose(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlModuleFree(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlModulePtr arg1 = (xmlModulePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlModuleFree.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlModule, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlModuleFree" "', argument " "1"" of type '" "xmlModulePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlModulePtr >(argp1);result = (int)xmlModuleFree(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_OK_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_OK));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_NOROOT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_NOROOT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_UNDECLAREDELEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_UNDECLAREDELEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_NOTTOPLEVEL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_NOTTOPLEVEL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_MISSING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_MISSING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_WRONGELEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_WRONGELEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_NOTYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_NOTYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_NOROLLBACK_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_NOROLLBACK));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_ISABSTRACT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_ISABSTRACT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_NOTEMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_NOTEMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_ELEMCONT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_ELEMCONT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_HAVEDEFAULT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_HAVEDEFAULT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_NOTNILLABLE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_NOTNILLABLE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_EXTRACONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_EXTRACONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_INVALIDATTR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_INVALIDATTR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_INVALIDELEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_INVALIDELEM));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_NOTDETERMINIST_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_NOTDETERMINIST));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_CONSTRUCT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_CONSTRUCT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_INTERNAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_INTERNAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_NOTSIMPLE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_NOTSIMPLE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_ATTRUNKNOWN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_ATTRUNKNOWN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_ATTRINVALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_ATTRINVALID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_VALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_VALUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_FACET_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_FACET));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR__get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ERR_XXX_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ERR_XXX));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_VAL_VC_I_CREATE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_VAL_VC_I_CREATE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlSchemaNewParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlSchemaParserCtxtPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaNewParserCtxt.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaNewParserCtxt" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (xmlSchemaParserCtxtPtr)xmlSchemaNewParserCtxt((char const *)arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaParserCtxt, 0 |  0 );
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaNewMemParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlSchemaParserCtxtPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaNewMemParserCtxt.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaNewMemParserCtxt" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlSchemaNewMemParserCtxt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlSchemaParserCtxtPtr)xmlSchemaNewMemParserCtxt((char const *)arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaParserCtxt, 0 |  0 );
  // free(arg1);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaNewDocParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlSchemaParserCtxtPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaNewDocParserCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlSchemaNewDocParserCtxt', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;result = (xmlSchemaParserCtxtPtr)xmlSchemaNewDocParserCtxt(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaParserCtxt, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaFreeParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaParserCtxtPtr arg1 = (xmlSchemaParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaFreeParserCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaFreeParserCtxt" "', argument " "1"" of type '" "xmlSchemaParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaParserCtxtPtr >(argp1);xmlSchemaFreeParserCtxt(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaSetParserErrors(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaParserCtxtPtr arg1 = (xmlSchemaParserCtxtPtr) 0 ;
  xmlSchemaValidityErrorFunc arg2 = (xmlSchemaValidityErrorFunc) 0 ;
  xmlSchemaValidityWarningFunc arg3 = (xmlSchemaValidityWarningFunc) 0 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaSetParserErrors.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaSetParserErrors" "', argument " "1"" of type '" "xmlSchemaParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaParserCtxtPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlSchemaSetParserErrors" "', argument " "2"" of type '" "xmlSchemaValidityErrorFunc""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlSchemaSetParserErrors" "', argument " "3"" of type '" "xmlSchemaValidityWarningFunc""'"); 
      }
    }
  }
  arg4 = getSwigCObjectPtr(args[3]);xmlSchemaSetParserErrors(arg1,arg2,arg3,arg4);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaSetParserStructuredErrors(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaParserCtxtPtr arg1 = (xmlSchemaParserCtxtPtr) 0 ;
  xmlStructuredErrorFunc arg2 = (xmlStructuredErrorFunc) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaSetParserStructuredErrors.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaSetParserStructuredErrors" "', argument " "1"" of type '" "xmlSchemaParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaParserCtxtPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const___xmlError__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlSchemaSetParserStructuredErrors" "', argument " "2"" of type '" "xmlStructuredErrorFunc""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);xmlSchemaSetParserStructuredErrors(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaGetParserErrors(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaParserCtxtPtr arg1 = (xmlSchemaParserCtxtPtr) 0 ;
  xmlSchemaValidityErrorFunc *arg2 = (xmlSchemaValidityErrorFunc *) 0 ;
  xmlSchemaValidityWarningFunc *arg3 = (xmlSchemaValidityWarningFunc *) 0 ;
  void **arg4 = (void **) 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 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaGetParserErrors.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaGetParserErrors" "', argument " "1"" of type '" "xmlSchemaParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaParserCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_f_p_void_p_q_const__char_v_______void, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaGetParserErrors" "', argument " "2"" of type '" "xmlSchemaValidityErrorFunc *""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaValidityErrorFunc * >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p_f_p_void_p_q_const__char_v_______void, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSchemaGetParserErrors" "', argument " "3"" of type '" "xmlSchemaValidityWarningFunc *""'"); 
  }
  arg3 = reinterpret_cast< xmlSchemaValidityWarningFunc * >(argp3);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_p_void, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSchemaGetParserErrors" "', argument " "4"" of type '" "void **""'"); 
  }
  arg4 = reinterpret_cast< void ** >(argp4);result = (int)xmlSchemaGetParserErrors(arg1,arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaIsValid(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValidCtxtPtr arg1 = (xmlSchemaValidCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaIsValid.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaIsValid" "', argument " "1"" of type '" "xmlSchemaValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValidCtxtPtr >(argp1);result = (int)xmlSchemaIsValid(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaParse(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaParserCtxtPtr arg1 = (xmlSchemaParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaParse.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaParse" "', argument " "1"" of type '" "xmlSchemaParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaParserCtxtPtr >(argp1);result = (xmlSchemaPtr)xmlSchemaParse(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchema, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaFree(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaPtr arg1 = (xmlSchemaPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaFree.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaFree" "', argument " "1"" of type '" "xmlSchemaPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaPtr >(argp1);xmlSchemaFree(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaDump(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  FILE *arg1 = (FILE *) 0 ;
  xmlSchemaPtr arg2 = (xmlSchemaPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaDump.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaDump" "', argument " "1"" of type '" "FILE *""'"); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaDump" "', argument " "2"" of type '" "xmlSchemaPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaPtr >(argp2);xmlSchemaDump(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaSetValidErrors(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValidCtxtPtr arg1 = (xmlSchemaValidCtxtPtr) 0 ;
  xmlSchemaValidityErrorFunc arg2 = (xmlSchemaValidityErrorFunc) 0 ;
  xmlSchemaValidityWarningFunc arg3 = (xmlSchemaValidityWarningFunc) 0 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaSetValidErrors.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaSetValidErrors" "', argument " "1"" of type '" "xmlSchemaValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValidCtxtPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlSchemaSetValidErrors" "', argument " "2"" of type '" "xmlSchemaValidityErrorFunc""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[2], (void**)(&arg3), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlSchemaSetValidErrors" "', argument " "3"" of type '" "xmlSchemaValidityWarningFunc""'"); 
      }
    }
  }
  arg4 = getSwigCObjectPtr(args[3]);xmlSchemaSetValidErrors(arg1,arg2,arg3,arg4);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaSetValidStructuredErrors(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValidCtxtPtr arg1 = (xmlSchemaValidCtxtPtr) 0 ;
  xmlStructuredErrorFunc arg2 = (xmlStructuredErrorFunc) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaSetValidStructuredErrors.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaSetValidStructuredErrors" "', argument " "1"" of type '" "xmlSchemaValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValidCtxtPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const___xmlError__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlSchemaSetValidStructuredErrors" "', argument " "2"" of type '" "xmlStructuredErrorFunc""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);xmlSchemaSetValidStructuredErrors(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaGetValidErrors(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValidCtxtPtr arg1 = (xmlSchemaValidCtxtPtr) 0 ;
  xmlSchemaValidityErrorFunc *arg2 = (xmlSchemaValidityErrorFunc *) 0 ;
  xmlSchemaValidityWarningFunc *arg3 = (xmlSchemaValidityWarningFunc *) 0 ;
  void **arg4 = (void **) 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 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaGetValidErrors.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaGetValidErrors" "', argument " "1"" of type '" "xmlSchemaValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_f_p_void_p_q_const__char_v_______void, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaGetValidErrors" "', argument " "2"" of type '" "xmlSchemaValidityErrorFunc *""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaValidityErrorFunc * >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p_f_p_void_p_q_const__char_v_______void, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSchemaGetValidErrors" "', argument " "3"" of type '" "xmlSchemaValidityWarningFunc *""'"); 
  }
  arg3 = reinterpret_cast< xmlSchemaValidityWarningFunc * >(argp3);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_p_void, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSchemaGetValidErrors" "', argument " "4"" of type '" "void **""'"); 
  }
  arg4 = reinterpret_cast< void ** >(argp4);result = (int)xmlSchemaGetValidErrors(arg1,arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaSetValidOptions(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValidCtxtPtr arg1 = (xmlSchemaValidCtxtPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaSetValidOptions.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaSetValidOptions" "', argument " "1"" of type '" "xmlSchemaValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValidCtxtPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlSchemaSetValidOptions" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlSchemaSetValidOptions(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValidateSetFilename(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValidCtxtPtr arg1 = (xmlSchemaValidCtxtPtr) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValidateSetFilename.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValidateSetFilename" "', argument " "1"" of type '" "xmlSchemaValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValidCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaValidateSetFilename" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }xmlSchemaValidateSetFilename(arg1,(char const *)arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValidCtxtGetOptions(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValidCtxtPtr arg1 = (xmlSchemaValidCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValidCtxtGetOptions.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValidCtxtGetOptions" "', argument " "1"" of type '" "xmlSchemaValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValidCtxtPtr >(argp1);result = (int)xmlSchemaValidCtxtGetOptions(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaNewValidCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaPtr arg1 = (xmlSchemaPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaValidCtxtPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaNewValidCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaNewValidCtxt" "', argument " "1"" of type '" "xmlSchemaPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaPtr >(argp1);result = (xmlSchemaValidCtxtPtr)xmlSchemaNewValidCtxt(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaValidCtxt, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaFreeValidCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValidCtxtPtr arg1 = (xmlSchemaValidCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaFreeValidCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaFreeValidCtxt" "', argument " "1"" of type '" "xmlSchemaValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValidCtxtPtr >(argp1);xmlSchemaFreeValidCtxt(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValidateDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValidCtxtPtr arg1 = (xmlSchemaValidCtxtPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValidateDoc.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValidateDoc" "', argument " "1"" of type '" "xmlSchemaValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlSchemaValidateDoc', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;result = (int)xmlSchemaValidateDoc(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValidateOneElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValidCtxtPtr arg1 = (xmlSchemaValidCtxtPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValidateOneElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValidateOneElement" "', argument " "1"" of type '" "xmlSchemaValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlSchemaValidateOneElement', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);result = (int)xmlSchemaValidateOneElement(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValidateStream(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValidCtxtPtr arg1 = (xmlSchemaValidCtxtPtr) 0 ;
  xmlParserInputBufferPtr arg2 = (xmlParserInputBufferPtr) 0 ;
  xmlCharEncoding arg3 ;
  xmlSAXHandlerPtr arg4 = (xmlSAXHandlerPtr) 0 ;
  void *arg5 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValidateStream.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValidateStream" "', argument " "1"" of type '" "xmlSchemaValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaValidateStream" "', argument " "2"" of type '" "xmlParserInputBufferPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlParserInputBufferPtr >(argp2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSchemaValidateStream" "', argument " "3"" of type '" "xmlCharEncoding""'");
  } 
  arg3 = static_cast< xmlCharEncoding >(val3);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSchemaValidateStream" "', argument " "4"" of type '" "xmlSAXHandlerPtr""'"); 
  }
  arg4 = reinterpret_cast< xmlSAXHandlerPtr >(argp4);arg5 = getSwigCObjectPtr(args[4]);result = (int)xmlSchemaValidateStream(arg1,arg2,arg3,arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValidateFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValidCtxtPtr arg1 = (xmlSchemaValidCtxtPtr) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValidateFile.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValidateFile" "', argument " "1"" of type '" "xmlSchemaValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValidCtxtPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaValidateFile" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSchemaValidateFile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlSchemaValidateFile(arg1,(char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValidCtxtGetParserCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValidCtxtPtr arg1 = (xmlSchemaValidCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlParserCtxtPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValidCtxtGetParserCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValidCtxtGetParserCtxt" "', argument " "1"" of type '" "xmlSchemaValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValidCtxtPtr >(argp1);result = (xmlParserCtxtPtr)xmlSchemaValidCtxtGetParserCtxt(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaSAXPlug(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValidCtxtPtr arg1 = (xmlSchemaValidCtxtPtr) 0 ;
  xmlSAXHandlerPtr *arg2 = (xmlSAXHandlerPtr *) 0 ;
  void **arg3 = (void **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  xmlSchemaSAXPlugPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaSAXPlug.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaSAXPlug" "', argument " "1"" of type '" "xmlSchemaValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValidCtxtPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaSAXPlug" "', argument " "2"" of type '" "xmlSAXHandlerPtr *""'"); 
  }
  arg2 = reinterpret_cast< xmlSAXHandlerPtr * >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p_void, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSchemaSAXPlug" "', argument " "3"" of type '" "void **""'"); 
  }
  arg3 = reinterpret_cast< void ** >(argp3);result = (xmlSchemaSAXPlugPtr)xmlSchemaSAXPlug(arg1,arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaSAXPlug, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaSAXUnplug(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaSAXPlugPtr arg1 = (xmlSchemaSAXPlugPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaSAXUnplug.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaSAXPlug, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaSAXUnplug" "', argument " "1"" of type '" "xmlSchemaSAXPlugPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaSAXPlugPtr >(argp1);result = (int)xmlSchemaSAXUnplug(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValidateSetLocator(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValidCtxtPtr arg1 = (xmlSchemaValidCtxtPtr) 0 ;
  xmlSchemaValidityLocatorFunc arg2 = (xmlSchemaValidityLocatorFunc) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValidateSetLocator.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValidateSetLocator" "', argument " "1"" of type '" "xmlSchemaValidCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValidCtxtPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_p_q_const__char_p_unsigned_long__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlSchemaValidateSetLocator" "', argument " "2"" of type '" "xmlSchemaValidityLocatorFunc""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);xmlSchemaValidateSetLocator(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_PARSER_SEVERITY_VALIDITY_WARNING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_SEVERITY_VALIDITY_WARNING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_SEVERITY_VALIDITY_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_SEVERITY_VALIDITY_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_SEVERITY_WARNING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_SEVERITY_WARNING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_SEVERITY_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_SEVERITY_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_TEXTREADER_MODE_INITIAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_TEXTREADER_MODE_INITIAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_TEXTREADER_MODE_INTERACTIVE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_TEXTREADER_MODE_INTERACTIVE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_TEXTREADER_MODE_ERROR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_TEXTREADER_MODE_ERROR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_TEXTREADER_MODE_EOF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_TEXTREADER_MODE_EOF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_TEXTREADER_MODE_CLOSED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_TEXTREADER_MODE_CLOSED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_TEXTREADER_MODE_READING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_TEXTREADER_MODE_READING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_LOADDTD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_LOADDTD));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_DEFAULTATTRS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_DEFAULTATTRS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_VALIDATE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_VALIDATE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_PARSER_SUBST_ENTITIES_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_PARSER_SUBST_ENTITIES));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_NONE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_NONE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_ELEMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_ELEMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_ATTRIBUTE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_ATTRIBUTE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_TEXT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_TEXT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_CDATA_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_CDATA));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_ENTITY_REFERENCE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_ENTITY_REFERENCE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_ENTITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_ENTITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_PROCESSING_INSTRUCTION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_PROCESSING_INSTRUCTION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_COMMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_COMMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_DOCUMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_DOCUMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_DOCUMENT_TYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_DOCUMENT_TYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_DOCUMENT_FRAGMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_DOCUMENT_FRAGMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_NOTATION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_NOTATION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_WHITESPACE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_WHITESPACE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_SIGNIFICANT_WHITESPACE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_SIGNIFICANT_WHITESPACE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_END_ELEMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_END_ELEMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_END_ENTITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_END_ENTITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_READER_TYPE_XML_DECLARATION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_READER_TYPE_XML_DECLARATION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlNewTextReader(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserInputBufferPtr arg1 = (xmlParserInputBufferPtr) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlTextReaderPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewTextReader.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewTextReader" "', argument " "1"" of type '" "xmlParserInputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserInputBufferPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlNewTextReader" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (xmlTextReaderPtr)xmlNewTextReader(arg1,(char const *)arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlTextReader, 0 |  0 );
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewTextReaderFilename(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlTextReaderPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewTextReaderFilename.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewTextReaderFilename" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }result = (xmlTextReaderPtr)xmlNewTextReaderFilename((char const *)arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlTextReader, 0 |  0 );
  // free(arg1);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeTextReader(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeTextReader.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeTextReader" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);xmlFreeTextReader(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderSetup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlParserInputBufferPtr arg2 = (xmlParserInputBufferPtr) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderSetup.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderSetup" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextReaderSetup" "', argument " "2"" of type '" "xmlParserInputBufferPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlParserInputBufferPtr >(argp2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextReaderSetup" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlTextReaderSetup" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlTextReaderSetup" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);result = (int)xmlTextReaderSetup(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  // free(arg3);
  // free(arg4);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderSetMaxAmplification(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderSetMaxAmplification.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderSetMaxAmplification" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlTextReaderSetMaxAmplification" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);xmlTextReaderSetMaxAmplification(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderGetLastError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlError *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderGetLastError.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderGetLastError" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlError *)xmlTextReaderGetLastError(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlError, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderRead(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderRead.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderRead" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderRead(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderReadInnerXml(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderReadInnerXml.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderReadInnerXml" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderReadInnerXml(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderReadOuterXml(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderReadOuterXml.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderReadOuterXml" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderReadOuterXml(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderReadString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderReadString.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderReadString" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderReadString(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderReadAttributeValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderReadAttributeValue.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderReadAttributeValue" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderReadAttributeValue(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderAttributeCount(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderAttributeCount.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderAttributeCount" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderAttributeCount(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderDepth(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderDepth.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderDepth" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderDepth(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderHasAttributes(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderHasAttributes.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderHasAttributes" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderHasAttributes(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderHasValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderHasValue.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderHasValue" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderHasValue(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderIsDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderIsDefault.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderIsDefault" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderIsDefault(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderIsEmptyElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderIsEmptyElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderIsEmptyElement" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderIsEmptyElement(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderNodeType(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderNodeType.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderNodeType" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderNodeType(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderQuoteChar(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderQuoteChar.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderQuoteChar" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderQuoteChar(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderReadState(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderReadState.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderReadState" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderReadState(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderIsNamespaceDecl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderIsNamespaceDecl.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderIsNamespaceDecl" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderIsNamespaceDecl(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderConstBaseUri(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderConstBaseUri.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderConstBaseUri" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderConstBaseUri(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderConstLocalName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderConstLocalName.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderConstLocalName" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderConstLocalName(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderConstName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderConstName.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderConstName" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderConstName(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderConstNamespaceUri(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderConstNamespaceUri.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderConstNamespaceUri" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderConstNamespaceUri(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderConstPrefix(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderConstPrefix.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderConstPrefix" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderConstPrefix(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderConstXmlLang(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderConstXmlLang.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderConstXmlLang" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderConstXmlLang(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderConstString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderConstString.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderConstString" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextReaderConstString" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlTextReaderConstString(arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderConstValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderConstValue.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderConstValue" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderConstValue(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderBaseUri(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderBaseUri.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderBaseUri" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderBaseUri(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderLocalName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderLocalName.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderLocalName" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderLocalName(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderName(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderName.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderName" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderName(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderNamespaceUri(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderNamespaceUri.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderNamespaceUri" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderNamespaceUri(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderPrefix(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderPrefix.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderPrefix" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderPrefix(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderXmlLang(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderXmlLang.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderXmlLang" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderXmlLang(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderValue.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderValue" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderValue(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderClose(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderClose.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderClose" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderClose(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderGetAttributeNo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderGetAttributeNo.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderGetAttributeNo" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlTextReaderGetAttributeNo" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlChar *)xmlTextReaderGetAttributeNo(arg1,arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderGetAttribute(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderGetAttribute.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderGetAttribute" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextReaderGetAttribute" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlTextReaderGetAttribute(arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderGetAttributeNs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderGetAttributeNs.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderGetAttributeNs" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextReaderGetAttributeNs" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextReaderGetAttributeNs" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (xmlChar *)xmlTextReaderGetAttributeNs(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderGetRemainder(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlParserInputBufferPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderGetRemainder.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderGetRemainder" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlParserInputBufferPtr)xmlTextReaderGetRemainder(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlParserInputBuffer, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderLookupNamespace(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderLookupNamespace.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderLookupNamespace" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextReaderLookupNamespace" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlChar *)xmlTextReaderLookupNamespace(arg1,(unsigned char const *)arg2);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderMoveToAttributeNo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderMoveToAttributeNo.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderMoveToAttributeNo" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlTextReaderMoveToAttributeNo" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlTextReaderMoveToAttributeNo(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderMoveToAttribute(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderMoveToAttribute.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderMoveToAttribute" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextReaderMoveToAttribute" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlTextReaderMoveToAttribute(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderMoveToAttributeNs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderMoveToAttributeNs.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderMoveToAttributeNs" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextReaderMoveToAttributeNs" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextReaderMoveToAttributeNs" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (int)xmlTextReaderMoveToAttributeNs(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderMoveToFirstAttribute(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderMoveToFirstAttribute.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderMoveToFirstAttribute" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderMoveToFirstAttribute(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderMoveToNextAttribute(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderMoveToNextAttribute.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderMoveToNextAttribute" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderMoveToNextAttribute(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderMoveToElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderMoveToElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderMoveToElement" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderMoveToElement(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderNormalization(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderNormalization.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderNormalization" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderNormalization(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderConstEncoding(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderConstEncoding.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderConstEncoding" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderConstEncoding(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderSetParserProp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderSetParserProp.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderSetParserProp" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlTextReaderSetParserProp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlTextReaderSetParserProp" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlTextReaderSetParserProp(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderGetParserProp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderGetParserProp.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderGetParserProp" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlTextReaderGetParserProp" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlTextReaderGetParserProp(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderCurrentNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderCurrentNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderCurrentNode" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlNodePtr)xmlTextReaderCurrentNode(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderGetParserLineNumber(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderGetParserLineNumber.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderGetParserLineNumber" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderGetParserLineNumber(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderGetParserColumnNumber(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderGetParserColumnNumber.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderGetParserColumnNumber" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderGetParserColumnNumber(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderPreserve(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderPreserve.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderPreserve" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlNodePtr)xmlTextReaderPreserve(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderPreservePattern(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar **arg3 = (xmlChar **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderPreservePattern.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderPreservePattern" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextReaderPreservePattern" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextReaderPreservePattern" "', argument " "3"" of type '" "xmlChar const **""'"); 
  }
  arg3 = reinterpret_cast< xmlChar ** >(argp3);result = (int)xmlTextReaderPreservePattern(arg1,(unsigned char const *)arg2,(unsigned char const **)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderCurrentDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlDocPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderCurrentDoc.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderCurrentDoc" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlDocPtr)xmlTextReaderCurrentDoc(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderExpand(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderExpand.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderExpand" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlNodePtr)xmlTextReaderExpand(arg1);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderNext(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderNext.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderNext" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderNext(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderNextSibling(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderNextSibling.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderNextSibling" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderNextSibling(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderIsValid(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderIsValid.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderIsValid" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderIsValid(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderRelaxNGValidate(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderRelaxNGValidate.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderRelaxNGValidate" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextReaderRelaxNGValidate" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (int)xmlTextReaderRelaxNGValidate(arg1,(char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderRelaxNGValidateCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlRelaxNGValidCtxtPtr arg2 = (xmlRelaxNGValidCtxtPtr) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderRelaxNGValidateCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderRelaxNGValidateCtxt" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlRelaxNGValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextReaderRelaxNGValidateCtxt" "', argument " "2"" of type '" "xmlRelaxNGValidCtxtPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlRelaxNGValidCtxtPtr >(argp2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlTextReaderRelaxNGValidateCtxt" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlTextReaderRelaxNGValidateCtxt(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderRelaxNGSetSchema(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlRelaxNGPtr arg2 = (xmlRelaxNGPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderRelaxNGSetSchema.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderRelaxNGSetSchema" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlRelaxNG, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextReaderRelaxNGSetSchema" "', argument " "2"" of type '" "xmlRelaxNGPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlRelaxNGPtr >(argp2);result = (int)xmlTextReaderRelaxNGSetSchema(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderSchemaValidate(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderSchemaValidate.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderSchemaValidate" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextReaderSchemaValidate" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (int)xmlTextReaderSchemaValidate(arg1,(char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderSchemaValidateCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlSchemaValidCtxtPtr arg2 = (xmlSchemaValidCtxtPtr) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderSchemaValidateCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderSchemaValidateCtxt" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlSchemaValidCtxt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextReaderSchemaValidateCtxt" "', argument " "2"" of type '" "xmlSchemaValidCtxtPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaValidCtxtPtr >(argp2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlTextReaderSchemaValidateCtxt" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlTextReaderSchemaValidateCtxt(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderSetSchema(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlSchemaPtr arg2 = (xmlSchemaPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderSetSchema.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderSetSchema" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextReaderSetSchema" "', argument " "2"" of type '" "xmlSchemaPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaPtr >(argp2);result = (int)xmlTextReaderSetSchema(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderConstXmlVersion(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderConstXmlVersion.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderConstXmlVersion" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (xmlChar *)xmlTextReaderConstXmlVersion(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderStandalone(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderStandalone.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderStandalone" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (int)xmlTextReaderStandalone(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderByteConsumed(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderByteConsumed.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderByteConsumed" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);result = (long)xmlTextReaderByteConsumed(arg1);
  jsresult = SWIG_From_long(static_cast< long >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReaderWalker(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlTextReaderPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReaderWalker.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlReaderWalker', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;result = (xmlTextReaderPtr)xmlReaderWalker(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlTextReader, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReaderForDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  xmlTextReaderPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReaderForDoc.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlReaderForDoc" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlReaderForDoc" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlReaderForDoc" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlReaderForDoc" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (xmlTextReaderPtr)xmlReaderForDoc((unsigned char const *)arg1,(char const *)arg2,(char const *)arg3,arg4);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlTextReader, 0 |  0 );
  
  // free(arg2);
  // free(arg3);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReaderForFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlTextReaderPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReaderForFile.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlReaderForFile" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlReaderForFile" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlReaderForFile" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlTextReaderPtr)xmlReaderForFile((char const *)arg1,(char const *)arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlTextReader, 0 |  0 );
  // free(arg1);
  // free(arg2);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReaderForMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int arg5 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  xmlTextReaderPtr result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReaderForMemory.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlReaderForMemory" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlReaderForMemory" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlReaderForMemory" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlReaderForMemory" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlReaderForMemory" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);result = (xmlTextReaderPtr)xmlReaderForMemory((char const *)arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlTextReader, 0 |  0 );
  // free(arg1);
  
  // free(arg3);
  // free(arg4);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReaderForFd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  xmlTextReaderPtr result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReaderForFd.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlReaderForFd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlReaderForFd" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlReaderForFd" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlReaderForFd" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (xmlTextReaderPtr)xmlReaderForFd(arg1,(char const *)arg2,(char const *)arg3,arg4);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlTextReader, 0 |  0 );
  
  // free(arg2);
  // free(arg3);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReaderForIO(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlInputReadCallback arg1 = (xmlInputReadCallback) 0 ;
  xmlInputCloseCallback arg2 = (xmlInputCloseCallback) 0 ;
  void *arg3 = (void *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  int arg6 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  xmlTextReaderPtr result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReaderForIO.");
  
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p_void_p_char_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlReaderForIO" "', argument " "1"" of type '" "xmlInputReadCallback""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlReaderForIO" "', argument " "2"" of type '" "xmlInputCloseCallback""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlReaderForIO" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else if (node::Buffer::HasInstance(args[4])) {
    arg5 = node::Buffer::Data(Nan::To<v8::Object>(args[4]).ToLocalChecked());
    // printf("data: %s - %i\n", arg5, strlen(arg5));
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlReaderForIO" "', argument " "5"" of type '" "char const *""'");
    }
    
    arg5 = reinterpret_cast< char * >(buf5);
  }ecode6 = SWIG_AsVal_int(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xmlReaderForIO" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);result = (xmlTextReaderPtr)xmlReaderForIO(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5,arg6);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlTextReader, 0 |  0 );
  
  
  
  // free(arg4);
  // free(arg5);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReaderNewWalker(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReaderNewWalker.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlReaderNewWalker" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlReaderNewWalker', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;result = (int)xmlReaderNewWalker(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReaderNewDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReaderNewDoc.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlReaderNewDoc" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlReaderNewDoc" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlReaderNewDoc" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlReaderNewDoc" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlReaderNewDoc" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);result = (int)xmlReaderNewDoc(arg1,(unsigned char const *)arg2,(char const *)arg3,(char const *)arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  // free(arg3);
  // free(arg4);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReaderNewFile(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReaderNewFile.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlReaderNewFile" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlReaderNewFile" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlReaderNewFile" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlReaderNewFile" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (int)xmlReaderNewFile(arg1,(char const *)arg2,(char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  // free(arg3);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReaderNewMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReaderNewMemory.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlReaderNewMemory" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlReaderNewMemory" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlReaderNewMemory" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlReaderNewMemory" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else if (node::Buffer::HasInstance(args[4])) {
    arg5 = node::Buffer::Data(Nan::To<v8::Object>(args[4]).ToLocalChecked());
    // printf("data: %s - %i\n", arg5, strlen(arg5));
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlReaderNewMemory" "', argument " "5"" of type '" "char const *""'");
    }
    
    arg5 = reinterpret_cast< char * >(buf5);
  }ecode6 = SWIG_AsVal_int(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xmlReaderNewMemory" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);result = (int)xmlReaderNewMemory(arg1,(char const *)arg2,arg3,(char const *)arg4,(char const *)arg5,arg6);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  // free(arg4);
  // free(arg5);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReaderNewFd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReaderNewFd.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlReaderNewFd" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlReaderNewFd" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlReaderNewFd" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlReaderNewFd" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }ecode5 = SWIG_AsVal_int(args[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "xmlReaderNewFd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);result = (int)xmlReaderNewFd(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  // free(arg3);
  // free(arg4);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlReaderNewIO(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlInputReadCallback arg2 = (xmlInputReadCallback) 0 ;
  xmlInputCloseCallback arg3 = (xmlInputCloseCallback) 0 ;
  void *arg4 = (void *) 0 ;
  char *arg5 = (char *) 0 ;
  char *arg6 = (char *) 0 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  size_t size6 = 0 ;
  int alloc6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int result;
  
  if (args.Length() < 7 || args.Length() > 7) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlReaderNewIO.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlReaderNewIO" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_char_int__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlReaderNewIO" "', argument " "2"" of type '" "xmlInputReadCallback""'"); 
      }
    }
  }
  {
    {
      int res = SWIG_ConvertFunctionPtr(args[2], (void**)(&arg3), SWIGTYPE_p_f_p_void__int);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlReaderNewIO" "', argument " "3"" of type '" "xmlInputCloseCallback""'"); 
      }
    }
  }
  arg4 = getSwigCObjectPtr(args[3]);if (args[4]->IsNull()) {
    arg5 = NULL;
  } else if (node::Buffer::HasInstance(args[4])) {
    arg5 = node::Buffer::Data(Nan::To<v8::Object>(args[4]).ToLocalChecked());
    // printf("data: %s - %i\n", arg5, strlen(arg5));
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlReaderNewIO" "', argument " "5"" of type '" "char const *""'");
    }
    
    arg5 = reinterpret_cast< char * >(buf5);
  }if (args[5]->IsNull()) {
    arg6 = NULL;
  } else if (node::Buffer::HasInstance(args[5])) {
    arg6 = node::Buffer::Data(Nan::To<v8::Object>(args[5]).ToLocalChecked());
    // printf("data: %s - %i\n", arg6, strlen(arg6));
  } else {
    res6 = SWIG_AsCharPtrAndSize(args[5], &buf6, &size6, &alloc6);
    
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlReaderNewIO" "', argument " "6"" of type '" "char const *""'");
    }
    
    arg6 = reinterpret_cast< char * >(buf6);
  }ecode7 = SWIG_AsVal_int(args[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "xmlReaderNewIO" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);result = (int)xmlReaderNewIO(arg1,arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,arg7);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  // free(arg5);
  // free(arg6);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderLocatorLineNumber(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderLocatorPtr arg1 = (xmlTextReaderLocatorPtr) 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderLocatorLineNumber.");
  
  arg1 = getSwigCObjectPtr(args[0]);result = (int)xmlTextReaderLocatorLineNumber(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderLocatorBaseURI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderLocatorPtr arg1 = (xmlTextReaderLocatorPtr) 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderLocatorBaseURI.");
  
  arg1 = getSwigCObjectPtr(args[0]);result = (xmlChar *)xmlTextReaderLocatorBaseURI(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderSetErrorHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlTextReaderErrorFunc arg2 = (xmlTextReaderErrorFunc) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderSetErrorHandler.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderSetErrorHandler" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_enum_xmlParserSeverities_p_void__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlTextReaderSetErrorHandler" "', argument " "2"" of type '" "xmlTextReaderErrorFunc""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);xmlTextReaderSetErrorHandler(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderSetStructuredErrorHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlStructuredErrorFunc arg2 = (xmlStructuredErrorFunc) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderSetStructuredErrorHandler.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderSetStructuredErrorHandler" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);{
    {
      int res = SWIG_ConvertFunctionPtr(args[1], (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const___xmlError__void);
      if (!SWIG_IsOK(res)) {
        SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlTextReaderSetStructuredErrorHandler" "', argument " "2"" of type '" "xmlStructuredErrorFunc""'"); 
      }
    }
  }
  arg3 = getSwigCObjectPtr(args[2]);xmlTextReaderSetStructuredErrorHandler(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextReaderGetErrorHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextReaderPtr arg1 = (xmlTextReaderPtr) 0 ;
  xmlTextReaderErrorFunc *arg2 = (xmlTextReaderErrorFunc *) 0 ;
  void **arg3 = (void **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextReaderGetErrorHandler.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextReader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextReaderGetErrorHandler" "', argument " "1"" of type '" "xmlTextReaderPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextReaderPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_f_p_void_p_q_const__char_enum_xmlParserSeverities_p_void__void, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextReaderGetErrorHandler" "', argument " "2"" of type '" "xmlTextReaderErrorFunc *""'"); 
  }
  arg2 = reinterpret_cast< xmlTextReaderErrorFunc * >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p_void, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextReaderGetErrorHandler" "', argument " "3"" of type '" "void **""'"); 
  }
  arg3 = reinterpret_cast< void ** >(argp3);xmlTextReaderGetErrorHandler(arg1,arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_SCHEMAS_UNKNOWN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_UNKNOWN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_STRING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_STRING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_NORMSTRING_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_NORMSTRING));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_DECIMAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_DECIMAL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TIME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_TIME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_GDAY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_GDAY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_GMONTH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_GMONTH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_GMONTHDAY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_GMONTHDAY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_GYEAR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_GYEAR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_GYEARMONTH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_GYEARMONTH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_DATE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_DATE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_DATETIME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_DATETIME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_DURATION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_DURATION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_FLOAT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_FLOAT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_DOUBLE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_DOUBLE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_BOOLEAN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_BOOLEAN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TOKEN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_TOKEN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_LANGUAGE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_LANGUAGE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_NMTOKEN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_NMTOKEN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_NMTOKENS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_NMTOKENS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_NAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_NAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_QNAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_QNAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_NCNAME_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_NCNAME));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ID));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_IDREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_IDREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_IDREFS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_IDREFS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ENTITY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ENTITY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ENTITIES_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ENTITIES));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_NOTATION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_NOTATION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ANYURI_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ANYURI));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_INTEGER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_INTEGER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_NPINTEGER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_NPINTEGER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_NINTEGER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_NINTEGER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_NNINTEGER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_NNINTEGER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_PINTEGER_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_PINTEGER));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_INT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_INT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_UINT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_UINT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_LONG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_LONG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ULONG_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ULONG));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_SHORT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_SHORT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_USHORT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_USHORT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_BYTE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_BYTE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_UBYTE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_UBYTE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_HEXBINARY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_HEXBINARY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_BASE64BINARY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_BASE64BINARY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ANYTYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ANYTYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ANYSIMPLETYPE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMAS_ANYSIMPLETYPE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_BASIC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_BASIC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_ANY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_ANY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_FACET_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_FACET));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_SIMPLE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_SIMPLE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_COMPLEX_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_COMPLEX));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_SEQUENCE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_SEQUENCE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_CHOICE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_CHOICE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_ALL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_ALL));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_SIMPLE_CONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_SIMPLE_CONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_COMPLEX_CONTENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_COMPLEX_CONTENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_UR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_UR));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_RESTRICTION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_RESTRICTION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_EXTENSION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_EXTENSION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_ELEMENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_ELEMENT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_ATTRIBUTE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_ATTRIBUTE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_ATTRIBUTEGROUP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_ATTRIBUTEGROUP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_GROUP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_GROUP));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_NOTATION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_NOTATION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_LIST_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_LIST));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_UNION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_UNION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_ANY_ATTRIBUTE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_ANY_ATTRIBUTE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_IDC_UNIQUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_IDC_UNIQUE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_IDC_KEY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_IDC_KEY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_IDC_KEYREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_IDC_KEYREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_PARTICLE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_PARTICLE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_TYPE_ATTRIBUTE_USE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_TYPE_ATTRIBUTE_USE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_FACET_MININCLUSIVE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_FACET_MININCLUSIVE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_FACET_MINEXCLUSIVE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_FACET_MINEXCLUSIVE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_FACET_MAXINCLUSIVE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_FACET_MAXINCLUSIVE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_FACET_MAXEXCLUSIVE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_FACET_MAXEXCLUSIVE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_FACET_TOTALDIGITS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_FACET_TOTALDIGITS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_FACET_FRACTIONDIGITS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_FACET_FRACTIONDIGITS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_FACET_PATTERN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_FACET_PATTERN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_FACET_ENUMERATION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_FACET_ENUMERATION));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_FACET_WHITESPACE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_FACET_WHITESPACE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_FACET_LENGTH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_FACET_LENGTH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_FACET_MAXLENGTH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_FACET_MAXLENGTH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_FACET_MINLENGTH_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_FACET_MINLENGTH));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_EXTRA_QNAMEREF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_EXTRA_QNAMEREF));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_EXTRA_ATTR_USE_PROHIB_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_EXTRA_ATTR_USE_PROHIB));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_CONTENT_UNKNOWN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_CONTENT_UNKNOWN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_CONTENT_EMPTY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_CONTENT_EMPTY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_CONTENT_ELEMENTS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_CONTENT_ELEMENTS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_CONTENT_MIXED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_CONTENT_MIXED));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_CONTENT_SIMPLE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_CONTENT_SIMPLE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_CONTENT_BASIC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_CONTENT_BASIC));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_CONTENT_ANY_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_CONTENT_ANY));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAnnot_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAnnot *arg1 = (_xmlSchemaAnnot *) 0 ;
  _xmlSchemaAnnot *arg2 = (_xmlSchemaAnnot *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAnnot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAnnot_next_set" "', argument " "1"" of type '" "_xmlSchemaAnnot *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAnnot * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAnnot, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAnnot_next_set" "', argument " "2"" of type '" "_xmlSchemaAnnot *""'"); 
  }
  arg2 = reinterpret_cast< _xmlSchemaAnnot * >(argp2);if (arg1) (arg1)->next = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAnnot_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAnnot *arg1 = (_xmlSchemaAnnot *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlSchemaAnnot *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAnnot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAnnot_next_get" "', argument " "1"" of type '" "_xmlSchemaAnnot *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAnnot * >(argp1);result = (_xmlSchemaAnnot *) ((arg1)->next);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAnnot, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAnnot_content_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAnnot *arg1 = (_xmlSchemaAnnot *) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAnnot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAnnot_content_set" "', argument " "1"" of type '" "_xmlSchemaAnnot *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAnnot * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlSchemaAnnot_content_set', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (arg1) (arg1)->content = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAnnot_content_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAnnot *arg1 = (_xmlSchemaAnnot *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAnnot, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAnnot_content_get" "', argument " "1"" of type '" "_xmlSchemaAnnot *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAnnot * >(argp1);result = (xmlNodePtr) ((arg1)->content);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlSchemaAnnot(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlSchemaAnnot *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlSchemaAnnot.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlSchemaAnnot.");
  result = (_xmlSchemaAnnot *)new _xmlSchemaAnnot();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlSchemaAnnot, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlSchemaAnnot(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlSchemaAnnot * arg1 = (_xmlSchemaAnnot *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ANYATTR_SKIP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ANYATTR_LAX_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ANYATTR_STRICT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ANY_SKIP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ANY_LAX_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ANY_STRICT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ATTR_USE_PROHIBITED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(0));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ATTR_USE_REQUIRED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ATTR_USE_OPTIONAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ATTR_GLOBAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 0));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ATTR_NSDEFAULT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 7));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ATTR_INTERNAL_RESOLVED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 8));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ATTR_FIXED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 9));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  xmlSchemaTypeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_type_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaAttribute_type_set" "', argument " "2"" of type '" "xmlSchemaTypeType""'");
  } 
  arg2 = static_cast< xmlSchemaTypeType >(val2);if (arg1) (arg1)->type = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaTypeType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_type_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (xmlSchemaTypeType) ((arg1)->type);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  _xmlSchemaAttribute *arg2 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_next_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAttribute, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttribute_next_set" "', argument " "2"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg2 = reinterpret_cast< _xmlSchemaAttribute * >(argp2);if (arg1) (arg1)->next = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlSchemaAttribute *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_next_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (_xmlSchemaAttribute *) ((arg1)->next);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_name_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttribute_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->name = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_name_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (xmlChar *) ((arg1)->name);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_id_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_id_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttribute_id_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->id = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_id_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_id_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (xmlChar *) ((arg1)->id);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_ref_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_ref_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttribute_ref_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->ref = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_ref_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_ref_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (xmlChar *) ((arg1)->ref);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_refNs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_refNs_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttribute_refNs_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->refNs = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_refNs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_refNs_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (xmlChar *) ((arg1)->refNs);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_typeName_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_typeName_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttribute_typeName_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->typeName = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_typeName_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_typeName_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (xmlChar *) ((arg1)->typeName);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_typeNs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_typeNs_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttribute_typeNs_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->typeNs = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_typeNs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_typeNs_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (xmlChar *) ((arg1)->typeNs);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_annot_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  xmlSchemaAnnotPtr arg2 = (xmlSchemaAnnotPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_annot_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAnnot, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttribute_annot_set" "', argument " "2"" of type '" "xmlSchemaAnnotPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaAnnotPtr >(argp2);if (arg1) (arg1)->annot = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_annot_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaAnnotPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_annot_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (xmlSchemaAnnotPtr) ((arg1)->annot);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAnnot, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_base_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  xmlSchemaTypePtr arg2 = (xmlSchemaTypePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_base_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttribute_base_set" "', argument " "2"" of type '" "xmlSchemaTypePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaTypePtr >(argp2);if (arg1) (arg1)->base = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_base_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaTypePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_base_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (xmlSchemaTypePtr) ((arg1)->base);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_occurs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_occurs_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaAttribute_occurs_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->occurs = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_occurs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_occurs_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (int) ((arg1)->occurs);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_defValue_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_defValue_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttribute_defValue_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->defValue = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_defValue_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_defValue_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (xmlChar *) ((arg1)->defValue);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_subtypes_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  xmlSchemaTypePtr arg2 = (xmlSchemaTypePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_subtypes_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttribute_subtypes_set" "', argument " "2"" of type '" "xmlSchemaTypePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaTypePtr >(argp2);if (arg1) (arg1)->subtypes = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_subtypes_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaTypePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_subtypes_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (xmlSchemaTypePtr) ((arg1)->subtypes);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_node_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_node_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlSchemaAttribute_node_set', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (arg1) (arg1)->node = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_node_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_node_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (xmlNodePtr) ((arg1)->node);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_targetNamespace_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_targetNamespace_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttribute_targetNamespace_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->targetNamespace = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_targetNamespace_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_targetNamespace_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (xmlChar *) ((arg1)->targetNamespace);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_flags_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_flags_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaAttribute_flags_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->flags = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_flags_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_flags_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (int) ((arg1)->flags);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_refPrefix_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_refPrefix_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttribute_refPrefix_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->refPrefix = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_refPrefix_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_refPrefix_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (xmlChar *) ((arg1)->refPrefix);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_defVal_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  xmlSchemaValPtr arg2 = (xmlSchemaValPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_defVal_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaVal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttribute_defVal_set" "', argument " "2"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaValPtr >(argp2);if (arg1) (arg1)->defVal = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_defVal_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaValPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_defVal_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (xmlSchemaValPtr) ((arg1)->defVal);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttribute_refDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  xmlSchemaAttributePtr arg2 = (xmlSchemaAttributePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_refDecl_set" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAttribute, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttribute_refDecl_set" "', argument " "2"" of type '" "xmlSchemaAttributePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaAttributePtr >(argp2);if (arg1) (arg1)->refDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttribute_refDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttribute *arg1 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaAttributePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttribute_refDecl_get" "', argument " "1"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttribute * >(argp1);result = (xmlSchemaAttributePtr) ((arg1)->refDecl);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlSchemaAttribute(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlSchemaAttribute *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlSchemaAttribute.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlSchemaAttribute.");
  result = (_xmlSchemaAttribute *)new _xmlSchemaAttribute();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlSchemaAttribute, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlSchemaAttribute(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlSchemaAttribute * arg1 = (_xmlSchemaAttribute *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlSchemaAttributeLink_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttributeLink *arg1 = (_xmlSchemaAttributeLink *) 0 ;
  _xmlSchemaAttributeLink *arg2 = (_xmlSchemaAttributeLink *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeLink, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeLink_next_set" "', argument " "1"" of type '" "_xmlSchemaAttributeLink *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeLink * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAttributeLink, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttributeLink_next_set" "', argument " "2"" of type '" "_xmlSchemaAttributeLink *""'"); 
  }
  arg2 = reinterpret_cast< _xmlSchemaAttributeLink * >(argp2);if (arg1) (arg1)->next = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttributeLink_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttributeLink *arg1 = (_xmlSchemaAttributeLink *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlSchemaAttributeLink *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeLink, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeLink_next_get" "', argument " "1"" of type '" "_xmlSchemaAttributeLink *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeLink * >(argp1);result = (_xmlSchemaAttributeLink *) ((arg1)->next);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAttributeLink, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttributeLink_attr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttributeLink *arg1 = (_xmlSchemaAttributeLink *) 0 ;
  _xmlSchemaAttribute *arg2 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeLink, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeLink_attr_set" "', argument " "1"" of type '" "_xmlSchemaAttributeLink *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeLink * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAttribute, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttributeLink_attr_set" "', argument " "2"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg2 = reinterpret_cast< _xmlSchemaAttribute * >(argp2);if (arg1) (arg1)->attr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttributeLink_attr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttributeLink *arg1 = (_xmlSchemaAttributeLink *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlSchemaAttribute *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeLink, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeLink_attr_get" "', argument " "1"" of type '" "_xmlSchemaAttributeLink *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeLink * >(argp1);result = (_xmlSchemaAttribute *) ((arg1)->attr);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlSchemaAttributeLink(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlSchemaAttributeLink *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlSchemaAttributeLink.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlSchemaAttributeLink.");
  result = (_xmlSchemaAttributeLink *)new _xmlSchemaAttributeLink();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlSchemaAttributeLink, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlSchemaAttributeLink(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlSchemaAttributeLink * arg1 = (_xmlSchemaAttributeLink *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue exports_XML_SCHEMAS_WILDCARD_COMPLETE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 0));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaWildcardNs_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaWildcardNs *arg1 = (_xmlSchemaWildcardNs *) 0 ;
  _xmlSchemaWildcardNs *arg2 = (_xmlSchemaWildcardNs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcardNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcardNs_next_set" "', argument " "1"" of type '" "_xmlSchemaWildcardNs *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcardNs * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaWildcardNs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaWildcardNs_next_set" "', argument " "2"" of type '" "_xmlSchemaWildcardNs *""'"); 
  }
  arg2 = reinterpret_cast< _xmlSchemaWildcardNs * >(argp2);if (arg1) (arg1)->next = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaWildcardNs_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaWildcardNs *arg1 = (_xmlSchemaWildcardNs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlSchemaWildcardNs *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcardNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcardNs_next_get" "', argument " "1"" of type '" "_xmlSchemaWildcardNs *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcardNs * >(argp1);result = (_xmlSchemaWildcardNs *) ((arg1)->next);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaWildcardNs, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaWildcardNs_value_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaWildcardNs *arg1 = (_xmlSchemaWildcardNs *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcardNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcardNs_value_set" "', argument " "1"" of type '" "_xmlSchemaWildcardNs *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcardNs * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaWildcardNs_value_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->value = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaWildcardNs_value_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaWildcardNs *arg1 = (_xmlSchemaWildcardNs *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcardNs, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcardNs_value_get" "', argument " "1"" of type '" "_xmlSchemaWildcardNs *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcardNs * >(argp1);result = (xmlChar *) ((arg1)->value);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlSchemaWildcardNs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlSchemaWildcardNs *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlSchemaWildcardNs.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlSchemaWildcardNs.");
  result = (_xmlSchemaWildcardNs *)new _xmlSchemaWildcardNs();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlSchemaWildcardNs, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlSchemaWildcardNs(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlSchemaWildcardNs * arg1 = (_xmlSchemaWildcardNs *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlSchemaWildcard_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  xmlSchemaTypeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_type_set" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaWildcard_type_set" "', argument " "2"" of type '" "xmlSchemaTypeType""'");
  } 
  arg2 = static_cast< xmlSchemaTypeType >(val2);if (arg1) (arg1)->type = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaWildcard_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaTypeType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_type_get" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);result = (xmlSchemaTypeType) ((arg1)->type);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaWildcard_id_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_id_set" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaWildcard_id_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->id = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaWildcard_id_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_id_get" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);result = (xmlChar *) ((arg1)->id);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaWildcard_annot_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  xmlSchemaAnnotPtr arg2 = (xmlSchemaAnnotPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_annot_set" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAnnot, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaWildcard_annot_set" "', argument " "2"" of type '" "xmlSchemaAnnotPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaAnnotPtr >(argp2);if (arg1) (arg1)->annot = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaWildcard_annot_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaAnnotPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_annot_get" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);result = (xmlSchemaAnnotPtr) ((arg1)->annot);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAnnot, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaWildcard_node_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_node_set" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlSchemaWildcard_node_set', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (arg1) (arg1)->node = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaWildcard_node_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_node_get" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);result = (xmlNodePtr) ((arg1)->node);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaWildcard_minOccurs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_minOccurs_set" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaWildcard_minOccurs_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->minOccurs = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaWildcard_minOccurs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_minOccurs_get" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);result = (int) ((arg1)->minOccurs);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaWildcard_maxOccurs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_maxOccurs_set" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaWildcard_maxOccurs_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->maxOccurs = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaWildcard_maxOccurs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_maxOccurs_get" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);result = (int) ((arg1)->maxOccurs);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaWildcard_processContents_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_processContents_set" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaWildcard_processContents_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->processContents = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaWildcard_processContents_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_processContents_get" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);result = (int) ((arg1)->processContents);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaWildcard_any_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_any_set" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaWildcard_any_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->any = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaWildcard_any_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_any_get" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);result = (int) ((arg1)->any);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaWildcard_nsSet_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  xmlSchemaWildcardNsPtr arg2 = (xmlSchemaWildcardNsPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_nsSet_set" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaWildcardNs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaWildcard_nsSet_set" "', argument " "2"" of type '" "xmlSchemaWildcardNsPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaWildcardNsPtr >(argp2);if (arg1) (arg1)->nsSet = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaWildcard_nsSet_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaWildcardNsPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_nsSet_get" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);result = (xmlSchemaWildcardNsPtr) ((arg1)->nsSet);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaWildcardNs, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaWildcard_negNsSet_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  xmlSchemaWildcardNsPtr arg2 = (xmlSchemaWildcardNsPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_negNsSet_set" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaWildcardNs, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaWildcard_negNsSet_set" "', argument " "2"" of type '" "xmlSchemaWildcardNsPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaWildcardNsPtr >(argp2);if (arg1) (arg1)->negNsSet = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaWildcard_negNsSet_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaWildcardNsPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_negNsSet_get" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);result = (xmlSchemaWildcardNsPtr) ((arg1)->negNsSet);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaWildcardNs, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaWildcard_flags_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_flags_set" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaWildcard_flags_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->flags = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaWildcard_flags_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaWildcard *arg1 = (_xmlSchemaWildcard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaWildcard_flags_get" "', argument " "1"" of type '" "_xmlSchemaWildcard *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaWildcard * >(argp1);result = (int) ((arg1)->flags);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlSchemaWildcard(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlSchemaWildcard *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlSchemaWildcard.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlSchemaWildcard.");
  result = (_xmlSchemaWildcard *)new _xmlSchemaWildcard();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlSchemaWildcard, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlSchemaWildcard(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlSchemaWildcard * arg1 = (_xmlSchemaWildcard *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 0));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ATTRGROUP_GLOBAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ATTRGROUP_MARKED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ATTRGROUP_REDEFINED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ATTRGROUP_HAS_REFS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 4));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttributeGroup_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  xmlSchemaTypeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_type_set" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaAttributeGroup_type_set" "', argument " "2"" of type '" "xmlSchemaTypeType""'");
  } 
  arg2 = static_cast< xmlSchemaTypeType >(val2);if (arg1) (arg1)->type = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttributeGroup_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaTypeType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_type_get" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);result = (xmlSchemaTypeType) ((arg1)->type);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttributeGroup_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  _xmlSchemaAttribute *arg2 = (_xmlSchemaAttribute *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_next_set" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAttribute, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttributeGroup_next_set" "', argument " "2"" of type '" "_xmlSchemaAttribute *""'"); 
  }
  arg2 = reinterpret_cast< _xmlSchemaAttribute * >(argp2);if (arg1) (arg1)->next = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttributeGroup_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlSchemaAttribute *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_next_get" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);result = (_xmlSchemaAttribute *) ((arg1)->next);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttributeGroup_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_name_set" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttributeGroup_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->name = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttributeGroup_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_name_get" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);result = (xmlChar *) ((arg1)->name);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttributeGroup_id_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_id_set" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttributeGroup_id_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->id = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttributeGroup_id_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_id_get" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);result = (xmlChar *) ((arg1)->id);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttributeGroup_ref_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_ref_set" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttributeGroup_ref_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->ref = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttributeGroup_ref_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_ref_get" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);result = (xmlChar *) ((arg1)->ref);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttributeGroup_refNs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_refNs_set" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttributeGroup_refNs_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->refNs = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttributeGroup_refNs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_refNs_get" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);result = (xmlChar *) ((arg1)->refNs);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttributeGroup_annot_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  xmlSchemaAnnotPtr arg2 = (xmlSchemaAnnotPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_annot_set" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAnnot, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttributeGroup_annot_set" "', argument " "2"" of type '" "xmlSchemaAnnotPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaAnnotPtr >(argp2);if (arg1) (arg1)->annot = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttributeGroup_annot_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaAnnotPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_annot_get" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);result = (xmlSchemaAnnotPtr) ((arg1)->annot);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAnnot, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttributeGroup_attributes_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  xmlSchemaAttributePtr arg2 = (xmlSchemaAttributePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_attributes_set" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAttribute, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttributeGroup_attributes_set" "', argument " "2"" of type '" "xmlSchemaAttributePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaAttributePtr >(argp2);if (arg1) (arg1)->attributes = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttributeGroup_attributes_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaAttributePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_attributes_get" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);result = (xmlSchemaAttributePtr) ((arg1)->attributes);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttributeGroup_node_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_node_set" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlSchemaAttributeGroup_node_set', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (arg1) (arg1)->node = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttributeGroup_node_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_node_get" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);result = (xmlNodePtr) ((arg1)->node);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttributeGroup_flags_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_flags_set" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaAttributeGroup_flags_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->flags = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttributeGroup_flags_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_flags_get" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);result = (int) ((arg1)->flags);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttributeGroup_attributeWildcard_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  xmlSchemaWildcardPtr arg2 = (xmlSchemaWildcardPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_attributeWildcard_set" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaWildcard, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttributeGroup_attributeWildcard_set" "', argument " "2"" of type '" "xmlSchemaWildcardPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaWildcardPtr >(argp2);if (arg1) (arg1)->attributeWildcard = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttributeGroup_attributeWildcard_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaWildcardPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_attributeWildcard_get" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);result = (xmlSchemaWildcardPtr) ((arg1)->attributeWildcard);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttributeGroup_refPrefix_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_refPrefix_set" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttributeGroup_refPrefix_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->refPrefix = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttributeGroup_refPrefix_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_refPrefix_get" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);result = (xmlChar *) ((arg1)->refPrefix);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttributeGroup_refItem_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  xmlSchemaAttributeGroupPtr arg2 = (xmlSchemaAttributeGroupPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_refItem_set" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAttributeGroup, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttributeGroup_refItem_set" "', argument " "2"" of type '" "xmlSchemaAttributeGroupPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaAttributeGroupPtr >(argp2);if (arg1) (arg1)->refItem = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttributeGroup_refItem_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaAttributeGroupPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_refItem_get" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);result = (xmlSchemaAttributeGroupPtr) ((arg1)->refItem);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttributeGroup_targetNamespace_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_targetNamespace_set" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaAttributeGroup_targetNamespace_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->targetNamespace = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttributeGroup_targetNamespace_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_targetNamespace_get" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);result = (xmlChar *) ((arg1)->targetNamespace);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaAttributeGroup_attrUses_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_attrUses_set" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->attrUses = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaAttributeGroup_attrUses_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaAttributeGroup *arg1 = (_xmlSchemaAttributeGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaAttributeGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaAttributeGroup_attrUses_get" "', argument " "1"" of type '" "_xmlSchemaAttributeGroup *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaAttributeGroup * >(argp1);result = (void *) ((arg1)->attrUses);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlSchemaAttributeGroup(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlSchemaAttributeGroup *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlSchemaAttributeGroup.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlSchemaAttributeGroup.");
  result = (_xmlSchemaAttributeGroup *)new _xmlSchemaAttributeGroup();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlSchemaAttributeGroup, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlSchemaAttributeGroup(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlSchemaAttributeGroup * arg1 = (_xmlSchemaAttributeGroup *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlSchemaTypeLink_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaTypeLink *arg1 = (_xmlSchemaTypeLink *) 0 ;
  _xmlSchemaTypeLink *arg2 = (_xmlSchemaTypeLink *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaTypeLink, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaTypeLink_next_set" "', argument " "1"" of type '" "_xmlSchemaTypeLink *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaTypeLink * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaTypeLink, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaTypeLink_next_set" "', argument " "2"" of type '" "_xmlSchemaTypeLink *""'"); 
  }
  arg2 = reinterpret_cast< _xmlSchemaTypeLink * >(argp2);if (arg1) (arg1)->next = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaTypeLink_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaTypeLink *arg1 = (_xmlSchemaTypeLink *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlSchemaTypeLink *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaTypeLink, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaTypeLink_next_get" "', argument " "1"" of type '" "_xmlSchemaTypeLink *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaTypeLink * >(argp1);result = (_xmlSchemaTypeLink *) ((arg1)->next);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaTypeLink, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaTypeLink_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaTypeLink *arg1 = (_xmlSchemaTypeLink *) 0 ;
  xmlSchemaTypePtr arg2 = (xmlSchemaTypePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaTypeLink, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaTypeLink_type_set" "', argument " "1"" of type '" "_xmlSchemaTypeLink *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaTypeLink * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaTypeLink_type_set" "', argument " "2"" of type '" "xmlSchemaTypePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaTypePtr >(argp2);if (arg1) (arg1)->type = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaTypeLink_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaTypeLink *arg1 = (_xmlSchemaTypeLink *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaTypePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaTypeLink, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaTypeLink_type_get" "', argument " "1"" of type '" "_xmlSchemaTypeLink *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaTypeLink * >(argp1);result = (xmlSchemaTypePtr) ((arg1)->type);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlSchemaTypeLink(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlSchemaTypeLink *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlSchemaTypeLink.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlSchemaTypeLink.");
  result = (_xmlSchemaTypeLink *)new _xmlSchemaTypeLink();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlSchemaTypeLink, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlSchemaTypeLink(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlSchemaTypeLink * arg1 = (_xmlSchemaTypeLink *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlSchemaFacetLink_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaFacetLink *arg1 = (_xmlSchemaFacetLink *) 0 ;
  _xmlSchemaFacetLink *arg2 = (_xmlSchemaFacetLink *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacetLink, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacetLink_next_set" "', argument " "1"" of type '" "_xmlSchemaFacetLink *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacetLink * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaFacetLink, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaFacetLink_next_set" "', argument " "2"" of type '" "_xmlSchemaFacetLink *""'"); 
  }
  arg2 = reinterpret_cast< _xmlSchemaFacetLink * >(argp2);if (arg1) (arg1)->next = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaFacetLink_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaFacetLink *arg1 = (_xmlSchemaFacetLink *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlSchemaFacetLink *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacetLink, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacetLink_next_get" "', argument " "1"" of type '" "_xmlSchemaFacetLink *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacetLink * >(argp1);result = (_xmlSchemaFacetLink *) ((arg1)->next);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaFacetLink, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaFacetLink_facet_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaFacetLink *arg1 = (_xmlSchemaFacetLink *) 0 ;
  xmlSchemaFacetPtr arg2 = (xmlSchemaFacetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacetLink, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacetLink_facet_set" "', argument " "1"" of type '" "_xmlSchemaFacetLink *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacetLink * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaFacet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaFacetLink_facet_set" "', argument " "2"" of type '" "xmlSchemaFacetPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaFacetPtr >(argp2);if (arg1) (arg1)->facet = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaFacetLink_facet_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaFacetLink *arg1 = (_xmlSchemaFacetLink *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaFacetPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacetLink, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacetLink_facet_get" "', argument " "1"" of type '" "_xmlSchemaFacetLink *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacetLink * >(argp1);result = (xmlSchemaFacetPtr) ((arg1)->facet);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlSchemaFacetLink(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlSchemaFacetLink *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlSchemaFacetLink.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlSchemaFacetLink.");
  result = (_xmlSchemaFacetLink *)new _xmlSchemaFacetLink();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlSchemaFacetLink, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlSchemaFacetLink(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlSchemaFacetLink * arg1 = (_xmlSchemaFacetLink *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_MIXED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 0));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_GLOBAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 4));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_VARIETY_ABSENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 5));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_VARIETY_LIST_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 6));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_VARIETY_UNION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 7));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_VARIETY_ATOMIC_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 8));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_FINAL_EXTENSION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 9));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_FINAL_RESTRICTION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 10));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_FINAL_LIST_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 11));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_FINAL_UNION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 12));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_FINAL_DEFAULT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 13));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 14));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_MARKED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 16));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_BLOCK_DEFAULT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 17));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_BLOCK_EXTENSION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 18));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_BLOCK_RESTRICTION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 19));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_ABSTRACT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 20));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_FACETSNEEDVALUE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 21));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_INTERNAL_RESOLVED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 22));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_INTERNAL_INVALID_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 23));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 24));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_WHITESPACE_REPLACE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 25));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 26));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_HAS_FACETS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 27));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_NORMVALUENEEDED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 28));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_FIXUP_1_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 29));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_TYPE_REDEFINED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 30));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlSchemaTypeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_type_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaType_type_set" "', argument " "2"" of type '" "xmlSchemaTypeType""'");
  } 
  arg2 = static_cast< xmlSchemaTypeType >(val2);if (arg1) (arg1)->type = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaTypeType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_type_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlSchemaTypeType) ((arg1)->type);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  _xmlSchemaType *arg2 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_next_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_next_set" "', argument " "2"" of type '" "_xmlSchemaType *""'"); 
  }
  arg2 = reinterpret_cast< _xmlSchemaType * >(argp2);if (arg1) (arg1)->next = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlSchemaType *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_next_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (_xmlSchemaType *) ((arg1)->next);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_name_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->name = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_name_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlChar *) ((arg1)->name);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_id_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_id_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_id_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->id = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_id_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_id_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlChar *) ((arg1)->id);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_ref_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_ref_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_ref_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->ref = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_ref_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_ref_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlChar *) ((arg1)->ref);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_refNs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_refNs_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_refNs_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->refNs = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_refNs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_refNs_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlChar *) ((arg1)->refNs);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_annot_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlSchemaAnnotPtr arg2 = (xmlSchemaAnnotPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_annot_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAnnot, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_annot_set" "', argument " "2"" of type '" "xmlSchemaAnnotPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaAnnotPtr >(argp2);if (arg1) (arg1)->annot = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_annot_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaAnnotPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_annot_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlSchemaAnnotPtr) ((arg1)->annot);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAnnot, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_subtypes_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlSchemaTypePtr arg2 = (xmlSchemaTypePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_subtypes_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_subtypes_set" "', argument " "2"" of type '" "xmlSchemaTypePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaTypePtr >(argp2);if (arg1) (arg1)->subtypes = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_subtypes_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaTypePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_subtypes_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlSchemaTypePtr) ((arg1)->subtypes);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_attributes_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlSchemaAttributePtr arg2 = (xmlSchemaAttributePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_attributes_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAttribute, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_attributes_set" "', argument " "2"" of type '" "xmlSchemaAttributePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaAttributePtr >(argp2);if (arg1) (arg1)->attributes = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_attributes_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaAttributePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_attributes_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlSchemaAttributePtr) ((arg1)->attributes);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_node_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_node_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlSchemaType_node_set', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (arg1) (arg1)->node = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_node_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_node_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlNodePtr) ((arg1)->node);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_minOccurs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_minOccurs_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaType_minOccurs_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->minOccurs = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_minOccurs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_minOccurs_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (int) ((arg1)->minOccurs);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_maxOccurs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_maxOccurs_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaType_maxOccurs_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->maxOccurs = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_maxOccurs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_maxOccurs_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (int) ((arg1)->maxOccurs);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_flags_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_flags_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaType_flags_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->flags = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_flags_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_flags_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (int) ((arg1)->flags);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_contentType_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlSchemaContentType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_contentType_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaType_contentType_set" "', argument " "2"" of type '" "xmlSchemaContentType""'");
  } 
  arg2 = static_cast< xmlSchemaContentType >(val2);if (arg1) (arg1)->contentType = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_contentType_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaContentType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_contentType_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlSchemaContentType) ((arg1)->contentType);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_base_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_base_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_base_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->base = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_base_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_base_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlChar *) ((arg1)->base);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_baseNs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_baseNs_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_baseNs_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->baseNs = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_baseNs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_baseNs_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlChar *) ((arg1)->baseNs);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_baseType_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlSchemaTypePtr arg2 = (xmlSchemaTypePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_baseType_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_baseType_set" "', argument " "2"" of type '" "xmlSchemaTypePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaTypePtr >(argp2);if (arg1) (arg1)->baseType = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_baseType_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaTypePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_baseType_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlSchemaTypePtr) ((arg1)->baseType);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_facets_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlSchemaFacetPtr arg2 = (xmlSchemaFacetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_facets_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaFacet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_facets_set" "', argument " "2"" of type '" "xmlSchemaFacetPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaFacetPtr >(argp2);if (arg1) (arg1)->facets = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_facets_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaFacetPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_facets_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlSchemaFacetPtr) ((arg1)->facets);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_redef_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  _xmlSchemaType *arg2 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_redef_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_redef_set" "', argument " "2"" of type '" "_xmlSchemaType *""'"); 
  }
  arg2 = reinterpret_cast< _xmlSchemaType * >(argp2);if (arg1) (arg1)->redef = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_redef_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlSchemaType *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_redef_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (_xmlSchemaType *) ((arg1)->redef);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_recurse_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_recurse_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaType_recurse_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->recurse = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_recurse_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_recurse_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (int) ((arg1)->recurse);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_attributeUses_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlSchemaAttributeLinkPtr *arg2 = (xmlSchemaAttributeLinkPtr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_attributeUses_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_p__xmlSchemaAttributeLink, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_attributeUses_set" "', argument " "2"" of type '" "xmlSchemaAttributeLinkPtr *""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaAttributeLinkPtr * >(argp2);if (arg1) (arg1)->attributeUses = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_attributeUses_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaAttributeLinkPtr *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_attributeUses_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlSchemaAttributeLinkPtr *) ((arg1)->attributeUses);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__xmlSchemaAttributeLink, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_attributeWildcard_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlSchemaWildcardPtr arg2 = (xmlSchemaWildcardPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_attributeWildcard_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaWildcard, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_attributeWildcard_set" "', argument " "2"" of type '" "xmlSchemaWildcardPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaWildcardPtr >(argp2);if (arg1) (arg1)->attributeWildcard = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_attributeWildcard_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaWildcardPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_attributeWildcard_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlSchemaWildcardPtr) ((arg1)->attributeWildcard);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_builtInType_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_builtInType_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaType_builtInType_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->builtInType = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_builtInType_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_builtInType_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (int) ((arg1)->builtInType);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_memberTypes_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlSchemaTypeLinkPtr arg2 = (xmlSchemaTypeLinkPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_memberTypes_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaTypeLink, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_memberTypes_set" "', argument " "2"" of type '" "xmlSchemaTypeLinkPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaTypeLinkPtr >(argp2);if (arg1) (arg1)->memberTypes = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_memberTypes_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaTypeLinkPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_memberTypes_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlSchemaTypeLinkPtr) ((arg1)->memberTypes);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaTypeLink, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_facetSet_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlSchemaFacetLinkPtr arg2 = (xmlSchemaFacetLinkPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_facetSet_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaFacetLink, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_facetSet_set" "', argument " "2"" of type '" "xmlSchemaFacetLinkPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaFacetLinkPtr >(argp2);if (arg1) (arg1)->facetSet = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_facetSet_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaFacetLinkPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_facetSet_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlSchemaFacetLinkPtr) ((arg1)->facetSet);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaFacetLink, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_refPrefix_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_refPrefix_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_refPrefix_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->refPrefix = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_refPrefix_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_refPrefix_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlChar *) ((arg1)->refPrefix);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_contentTypeDef_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlSchemaTypePtr arg2 = (xmlSchemaTypePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_contentTypeDef_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_contentTypeDef_set" "', argument " "2"" of type '" "xmlSchemaTypePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaTypePtr >(argp2);if (arg1) (arg1)->contentTypeDef = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_contentTypeDef_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaTypePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_contentTypeDef_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlSchemaTypePtr) ((arg1)->contentTypeDef);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_contModel_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlRegexpPtr arg2 = (xmlRegexpPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_contModel_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlRegexp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_contModel_set" "', argument " "2"" of type '" "xmlRegexpPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlRegexpPtr >(argp2);if (arg1) (arg1)->contModel = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_contModel_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlRegexpPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_contModel_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlRegexpPtr) ((arg1)->contModel);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlRegexp, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_targetNamespace_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_targetNamespace_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaType_targetNamespace_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->targetNamespace = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_targetNamespace_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_targetNamespace_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (xmlChar *) ((arg1)->targetNamespace);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaType_attrUses_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_attrUses_set" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->attrUses = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaType_attrUses_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaType *arg1 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaType_attrUses_get" "', argument " "1"" of type '" "_xmlSchemaType *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaType * >(argp1);result = (void *) ((arg1)->attrUses);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlSchemaType(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlSchemaType *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlSchemaType.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlSchemaType.");
  result = (_xmlSchemaType *)new _xmlSchemaType();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlSchemaType, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlSchemaType(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlSchemaType * arg1 = (_xmlSchemaType *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_NILLABLE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 0));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_GLOBAL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_DEFAULT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_FIXED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_ABSTRACT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 4));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_TOPLEVEL_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 5));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_REF_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 6));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_NSDEFAULT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 7));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_INTERNAL_RESOLVED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 8));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_CIRCULAR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 9));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_BLOCK_ABSENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 10));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_BLOCK_EXTENSION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 11));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_BLOCK_RESTRICTION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 12));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 13));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_FINAL_ABSENT_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 14));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_FINAL_EXTENSION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 15));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_FINAL_RESTRICTION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 16));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 17));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_ELEM_INTERNAL_CHECKED_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 18));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlSchemaTypeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_type_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaElement_type_set" "', argument " "2"" of type '" "xmlSchemaTypeType""'");
  } 
  arg2 = static_cast< xmlSchemaTypeType >(val2);if (arg1) (arg1)->type = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaTypeType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_type_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlSchemaTypeType) ((arg1)->type);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  _xmlSchemaType *arg2 = (_xmlSchemaType *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_next_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_next_set" "', argument " "2"" of type '" "_xmlSchemaType *""'"); 
  }
  arg2 = reinterpret_cast< _xmlSchemaType * >(argp2);if (arg1) (arg1)->next = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlSchemaType *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_next_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (_xmlSchemaType *) ((arg1)->next);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_name_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->name = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_name_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlChar *) ((arg1)->name);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_id_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_id_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_id_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->id = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_id_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_id_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlChar *) ((arg1)->id);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_ref_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_ref_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_ref_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->ref = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_ref_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_ref_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlChar *) ((arg1)->ref);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_refNs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_refNs_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_refNs_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->refNs = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_refNs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_refNs_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlChar *) ((arg1)->refNs);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_annot_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlSchemaAnnotPtr arg2 = (xmlSchemaAnnotPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_annot_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAnnot, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_annot_set" "', argument " "2"" of type '" "xmlSchemaAnnotPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaAnnotPtr >(argp2);if (arg1) (arg1)->annot = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_annot_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaAnnotPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_annot_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlSchemaAnnotPtr) ((arg1)->annot);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAnnot, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_subtypes_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlSchemaTypePtr arg2 = (xmlSchemaTypePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_subtypes_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaType, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_subtypes_set" "', argument " "2"" of type '" "xmlSchemaTypePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaTypePtr >(argp2);if (arg1) (arg1)->subtypes = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_subtypes_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaTypePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_subtypes_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlSchemaTypePtr) ((arg1)->subtypes);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_attributes_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlSchemaAttributePtr arg2 = (xmlSchemaAttributePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_attributes_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAttribute, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_attributes_set" "', argument " "2"" of type '" "xmlSchemaAttributePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaAttributePtr >(argp2);if (arg1) (arg1)->attributes = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_attributes_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaAttributePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_attributes_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlSchemaAttributePtr) ((arg1)->attributes);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAttribute, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_node_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_node_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlSchemaElement_node_set', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (arg1) (arg1)->node = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_node_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_node_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlNodePtr) ((arg1)->node);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_minOccurs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_minOccurs_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaElement_minOccurs_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->minOccurs = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_minOccurs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_minOccurs_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (int) ((arg1)->minOccurs);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_maxOccurs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_maxOccurs_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaElement_maxOccurs_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->maxOccurs = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_maxOccurs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_maxOccurs_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (int) ((arg1)->maxOccurs);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_flags_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_flags_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaElement_flags_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->flags = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_flags_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_flags_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (int) ((arg1)->flags);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_targetNamespace_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_targetNamespace_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_targetNamespace_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->targetNamespace = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_targetNamespace_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_targetNamespace_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlChar *) ((arg1)->targetNamespace);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_namedType_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_namedType_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_namedType_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->namedType = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_namedType_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_namedType_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlChar *) ((arg1)->namedType);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_namedTypeNs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_namedTypeNs_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_namedTypeNs_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->namedTypeNs = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_namedTypeNs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_namedTypeNs_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlChar *) ((arg1)->namedTypeNs);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_substGroup_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_substGroup_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_substGroup_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->substGroup = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_substGroup_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_substGroup_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlChar *) ((arg1)->substGroup);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_substGroupNs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_substGroupNs_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_substGroupNs_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->substGroupNs = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_substGroupNs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_substGroupNs_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlChar *) ((arg1)->substGroupNs);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_scope_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_scope_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_scope_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->scope = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_scope_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_scope_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlChar *) ((arg1)->scope);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_value_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_value_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_value_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->value = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_value_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_value_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlChar *) ((arg1)->value);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_refDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  _xmlSchemaElement *arg2 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_refDecl_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaElement, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_refDecl_set" "', argument " "2"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg2 = reinterpret_cast< _xmlSchemaElement * >(argp2);if (arg1) (arg1)->refDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_refDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlSchemaElement *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_refDecl_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (_xmlSchemaElement *) ((arg1)->refDecl);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_contModel_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlRegexpPtr arg2 = (xmlRegexpPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_contModel_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlRegexp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_contModel_set" "', argument " "2"" of type '" "xmlRegexpPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlRegexpPtr >(argp2);if (arg1) (arg1)->contModel = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_contModel_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlRegexpPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_contModel_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlRegexpPtr) ((arg1)->contModel);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlRegexp, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_contentType_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlSchemaContentType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_contentType_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaElement_contentType_set" "', argument " "2"" of type '" "xmlSchemaContentType""'");
  } 
  arg2 = static_cast< xmlSchemaContentType >(val2);if (arg1) (arg1)->contentType = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_contentType_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaContentType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_contentType_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlSchemaContentType) ((arg1)->contentType);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_refPrefix_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_refPrefix_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_refPrefix_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->refPrefix = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_refPrefix_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_refPrefix_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlChar *) ((arg1)->refPrefix);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_defVal_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  xmlSchemaValPtr arg2 = (xmlSchemaValPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_defVal_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaVal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaElement_defVal_set" "', argument " "2"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaValPtr >(argp2);if (arg1) (arg1)->defVal = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_defVal_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaValPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_defVal_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (xmlSchemaValPtr) ((arg1)->defVal);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaElement_idcs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_idcs_set" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->idcs = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaElement_idcs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaElement *arg1 = (_xmlSchemaElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaElement_idcs_get" "', argument " "1"" of type '" "_xmlSchemaElement *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaElement * >(argp1);result = (void *) ((arg1)->idcs);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlSchemaElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlSchemaElement *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlSchemaElement.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlSchemaElement.");
  result = (_xmlSchemaElement *)new _xmlSchemaElement();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlSchemaElement, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlSchemaElement(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlSchemaElement * arg1 = (_xmlSchemaElement *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue exports_XML_SCHEMAS_FACET_UNKNOWN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(0));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_FACET_PRESERVE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_FACET_REPLACE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_FACET_COLLAPSE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaFacet_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  xmlSchemaTypeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_type_set" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaFacet_type_set" "', argument " "2"" of type '" "xmlSchemaTypeType""'");
  } 
  arg2 = static_cast< xmlSchemaTypeType >(val2);if (arg1) (arg1)->type = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaFacet_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaTypeType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_type_get" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);result = (xmlSchemaTypeType) ((arg1)->type);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaFacet_next_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  _xmlSchemaFacet *arg2 = (_xmlSchemaFacet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_next_set" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaFacet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaFacet_next_set" "', argument " "2"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg2 = reinterpret_cast< _xmlSchemaFacet * >(argp2);if (arg1) (arg1)->next = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaFacet_next_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  _xmlSchemaFacet *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_next_get" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);result = (_xmlSchemaFacet *) ((arg1)->next);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaFacet_value_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_value_set" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaFacet_value_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->value = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaFacet_value_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_value_get" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);result = (xmlChar *) ((arg1)->value);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaFacet_id_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_id_set" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaFacet_id_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->id = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaFacet_id_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_id_get" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);result = (xmlChar *) ((arg1)->id);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaFacet_annot_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  xmlSchemaAnnotPtr arg2 = (xmlSchemaAnnotPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_annot_set" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAnnot, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaFacet_annot_set" "', argument " "2"" of type '" "xmlSchemaAnnotPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaAnnotPtr >(argp2);if (arg1) (arg1)->annot = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaFacet_annot_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaAnnotPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_annot_get" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);result = (xmlSchemaAnnotPtr) ((arg1)->annot);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAnnot, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaFacet_node_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_node_set" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlSchemaFacet_node_set', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);if (arg1) (arg1)->node = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaFacet_node_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlNodePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_node_get" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);result = (xmlNodePtr) ((arg1)->node);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlNode);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaFacet_fixed_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_fixed_set" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaFacet_fixed_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->fixed = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaFacet_fixed_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_fixed_get" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);result = (int) ((arg1)->fixed);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaFacet_whitespace_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_whitespace_set" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaFacet_whitespace_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->whitespace = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaFacet_whitespace_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_whitespace_get" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);result = (int) ((arg1)->whitespace);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaFacet_val_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  xmlSchemaValPtr arg2 = (xmlSchemaValPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_val_set" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaVal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaFacet_val_set" "', argument " "2"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaValPtr >(argp2);if (arg1) (arg1)->val = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaFacet_val_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaValPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_val_get" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);result = (xmlSchemaValPtr) ((arg1)->val);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaFacet_regexp_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  xmlRegexpPtr arg2 = (xmlRegexpPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_regexp_set" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlRegexp, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaFacet_regexp_set" "', argument " "2"" of type '" "xmlRegexpPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlRegexpPtr >(argp2);if (arg1) (arg1)->regexp = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaFacet_regexp_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaFacet *arg1 = (_xmlSchemaFacet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlRegexpPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaFacet_regexp_get" "', argument " "1"" of type '" "_xmlSchemaFacet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaFacet * >(argp1);result = (xmlRegexpPtr) ((arg1)->regexp);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlRegexp, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlSchemaFacet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlSchemaFacet *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlSchemaFacet.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlSchemaFacet.");
  result = (_xmlSchemaFacet *)new _xmlSchemaFacet();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlSchemaFacet, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlSchemaFacet(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlSchemaFacet * arg1 = (_xmlSchemaFacet *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static void _wrap__xmlSchemaNotation_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaNotation *arg1 = (_xmlSchemaNotation *) 0 ;
  xmlSchemaTypeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaNotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaNotation_type_set" "', argument " "1"" of type '" "_xmlSchemaNotation *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaNotation * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchemaNotation_type_set" "', argument " "2"" of type '" "xmlSchemaTypeType""'");
  } 
  arg2 = static_cast< xmlSchemaTypeType >(val2);if (arg1) (arg1)->type = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaNotation_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaNotation *arg1 = (_xmlSchemaNotation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaTypeType result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaNotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaNotation_type_get" "', argument " "1"" of type '" "_xmlSchemaNotation *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaNotation * >(argp1);result = (xmlSchemaTypeType) ((arg1)->type);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaNotation_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaNotation *arg1 = (_xmlSchemaNotation *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaNotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaNotation_name_set" "', argument " "1"" of type '" "_xmlSchemaNotation *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaNotation * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaNotation_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->name = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaNotation_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaNotation *arg1 = (_xmlSchemaNotation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaNotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaNotation_name_get" "', argument " "1"" of type '" "_xmlSchemaNotation *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaNotation * >(argp1);result = (xmlChar *) ((arg1)->name);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaNotation_annot_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaNotation *arg1 = (_xmlSchemaNotation *) 0 ;
  xmlSchemaAnnotPtr arg2 = (xmlSchemaAnnotPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaNotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaNotation_annot_set" "', argument " "1"" of type '" "_xmlSchemaNotation *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaNotation * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAnnot, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaNotation_annot_set" "', argument " "2"" of type '" "xmlSchemaAnnotPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaAnnotPtr >(argp2);if (arg1) (arg1)->annot = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaNotation_annot_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaNotation *arg1 = (_xmlSchemaNotation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaAnnotPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaNotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaNotation_annot_get" "', argument " "1"" of type '" "_xmlSchemaNotation *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaNotation * >(argp1);result = (xmlSchemaAnnotPtr) ((arg1)->annot);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAnnot, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaNotation_identifier_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaNotation *arg1 = (_xmlSchemaNotation *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaNotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaNotation_identifier_set" "', argument " "1"" of type '" "_xmlSchemaNotation *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaNotation * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaNotation_identifier_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->identifier = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaNotation_identifier_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaNotation *arg1 = (_xmlSchemaNotation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaNotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaNotation_identifier_get" "', argument " "1"" of type '" "_xmlSchemaNotation *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaNotation * >(argp1);result = (xmlChar *) ((arg1)->identifier);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchemaNotation_targetNamespace_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchemaNotation *arg1 = (_xmlSchemaNotation *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaNotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaNotation_targetNamespace_set" "', argument " "1"" of type '" "_xmlSchemaNotation *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaNotation * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchemaNotation_targetNamespace_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->targetNamespace = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchemaNotation_targetNamespace_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchemaNotation *arg1 = (_xmlSchemaNotation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchemaNotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchemaNotation_targetNamespace_get" "', argument " "1"" of type '" "_xmlSchemaNotation *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchemaNotation * >(argp1);result = (xmlChar *) ((arg1)->targetNamespace);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlSchemaNotation(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlSchemaNotation *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlSchemaNotation.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlSchemaNotation.");
  result = (_xmlSchemaNotation *)new _xmlSchemaNotation();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlSchemaNotation, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlSchemaNotation(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlSchemaNotation * arg1 = (_xmlSchemaNotation *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue exports_XML_SCHEMAS_QUALIF_ELEM_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 0));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_QUALIF_ATTR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 1));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_FINAL_DEFAULT_EXTENSION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 2));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 3));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_FINAL_DEFAULT_LIST_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 4));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_FINAL_DEFAULT_UNION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 5));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 6));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 7));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 8));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMAS_INCLUDING_CONVERT_NS_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(1 << 9));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_name_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_name_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchema_name_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->name = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_name_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_name_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (xmlChar *) ((arg1)->name);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_targetNamespace_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_targetNamespace_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchema_targetNamespace_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->targetNamespace = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_targetNamespace_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_targetNamespace_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (xmlChar *) ((arg1)->targetNamespace);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_version_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_version_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchema_version_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->version = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_version_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_version_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (xmlChar *) ((arg1)->version);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_id_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_id_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);if (value->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(value, &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchema_id_set" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (arg1) (arg1)->id = (xmlChar const *)arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_id_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_id_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (xmlChar *) ((arg1)->id);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_doc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  xmlDocPtr arg2 = (xmlDocPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_doc_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);res2 = SWIG_ConvertPtr(value, &arg20, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '_xmlSchema_doc_set', argument 2 of type 'xmlDocPtr'"); 
  }
  arg2 = (xmlDocPtr) arg20;if (arg1) (arg1)->doc = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_doc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlDocPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_doc_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (xmlDocPtr) ((arg1)->doc);
  jsresult = createWrap((xmlNode*) result, SWIGTYPE_p__xmlDoc);
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_annot_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  xmlSchemaAnnotPtr arg2 = (xmlSchemaAnnotPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_annot_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlSchemaAnnot, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchema_annot_set" "', argument " "2"" of type '" "xmlSchemaAnnotPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaAnnotPtr >(argp2);if (arg1) (arg1)->annot = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_annot_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaAnnotPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_annot_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (xmlSchemaAnnotPtr) ((arg1)->annot);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaAnnot, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_flags_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_flags_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchema_flags_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->flags = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_flags_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_flags_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (int) ((arg1)->flags);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_typeDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  xmlHashTablePtr arg2 = (xmlHashTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_typeDecl_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlHashTable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchema_typeDecl_set" "', argument " "2"" of type '" "xmlHashTablePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlHashTablePtr >(argp2);if (arg1) (arg1)->typeDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_typeDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlHashTablePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_typeDecl_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (xmlHashTablePtr) ((arg1)->typeDecl);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_attrDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  xmlHashTablePtr arg2 = (xmlHashTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_attrDecl_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlHashTable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchema_attrDecl_set" "', argument " "2"" of type '" "xmlHashTablePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlHashTablePtr >(argp2);if (arg1) (arg1)->attrDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_attrDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlHashTablePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_attrDecl_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (xmlHashTablePtr) ((arg1)->attrDecl);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_attrgrpDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  xmlHashTablePtr arg2 = (xmlHashTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_attrgrpDecl_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlHashTable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchema_attrgrpDecl_set" "', argument " "2"" of type '" "xmlHashTablePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlHashTablePtr >(argp2);if (arg1) (arg1)->attrgrpDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_attrgrpDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlHashTablePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_attrgrpDecl_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (xmlHashTablePtr) ((arg1)->attrgrpDecl);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_elemDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  xmlHashTablePtr arg2 = (xmlHashTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_elemDecl_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlHashTable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchema_elemDecl_set" "', argument " "2"" of type '" "xmlHashTablePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlHashTablePtr >(argp2);if (arg1) (arg1)->elemDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_elemDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlHashTablePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_elemDecl_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (xmlHashTablePtr) ((arg1)->elemDecl);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_notaDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  xmlHashTablePtr arg2 = (xmlHashTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_notaDecl_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlHashTable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchema_notaDecl_set" "', argument " "2"" of type '" "xmlHashTablePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlHashTablePtr >(argp2);if (arg1) (arg1)->notaDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_notaDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlHashTablePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_notaDecl_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (xmlHashTablePtr) ((arg1)->notaDecl);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_schemasImports_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  xmlHashTablePtr arg2 = (xmlHashTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_schemasImports_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlHashTable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchema_schemasImports_set" "', argument " "2"" of type '" "xmlHashTablePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlHashTablePtr >(argp2);if (arg1) (arg1)->schemasImports = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_schemasImports_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlHashTablePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_schemasImports_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (xmlHashTablePtr) ((arg1)->schemasImports);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema__private_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema__private_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->_private = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema__private_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema__private_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (void *) ((arg1)->_private);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_groupDecl_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  xmlHashTablePtr arg2 = (xmlHashTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_groupDecl_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlHashTable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchema_groupDecl_set" "', argument " "2"" of type '" "xmlHashTablePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlHashTablePtr >(argp2);if (arg1) (arg1)->groupDecl = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_groupDecl_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlHashTablePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_groupDecl_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (xmlHashTablePtr) ((arg1)->groupDecl);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_dict_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  xmlDictPtr arg2 = (xmlDictPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_dict_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlDict, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchema_dict_set" "', argument " "2"" of type '" "xmlDictPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlDictPtr >(argp2);if (arg1) (arg1)->dict = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_dict_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlDictPtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_dict_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (xmlDictPtr) ((arg1)->dict);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlDict, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_includes_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_includes_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->includes = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_includes_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_includes_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (void *) ((arg1)->includes);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_preserve_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_preserve_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchema_preserve_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->preserve = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_preserve_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_preserve_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (int) ((arg1)->preserve);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_counter_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_counter_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlSchema_counter_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (arg1) (arg1)->counter = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_counter_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_counter_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (int) ((arg1)->counter);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_idcDef_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  xmlHashTablePtr arg2 = (xmlHashTablePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_idcDef_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p__xmlHashTable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlSchema_idcDef_set" "', argument " "2"" of type '" "xmlHashTablePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlHashTablePtr >(argp2);if (arg1) (arg1)->idcDef = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_idcDef_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlHashTablePtr result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_idcDef_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (xmlHashTablePtr) ((arg1)->idcDef);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlHashTable, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap__xmlSchema_volatiles_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_volatiles_set" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);arg2 = getSwigCObjectPtr(value);if (arg1) (arg1)->volatiles = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlSchema_volatiles_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlSchema *arg1 = (_xmlSchema *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlSchema, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlSchema_volatiles_get" "', argument " "1"" of type '" "_xmlSchema *""'"); 
  }
  arg1 = reinterpret_cast< _xmlSchema * >(argp1);result = (void *) ((arg1)->volatiles);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_new__xmlSchema(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlSchema *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlSchema.");
  if(args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlSchema.");
  result = (_xmlSchema *)new _xmlSchema();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlSchema, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_delete__xmlSchema(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
  SWIGV8_Proxy *proxy = data.GetParameter();
  
  if(proxy->swigCMemOwn && proxy->swigCObject) {
    _xmlSchema * arg1 = (_xmlSchema *)proxy->swigCObject;
    delete arg1;
  }
  delete proxy;
}


static SwigV8ReturnValue _wrap_xmlSchemaFreeType(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaTypePtr arg1 = (xmlSchemaTypePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaFreeType.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaFreeType" "', argument " "1"" of type '" "xmlSchemaTypePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaTypePtr >(argp1);xmlSchemaFreeType(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaFreeWildcard(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaWildcardPtr arg1 = (xmlSchemaWildcardPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaFreeWildcard.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaWildcard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaFreeWildcard" "', argument " "1"" of type '" "xmlSchemaWildcardPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaWildcardPtr >(argp1);xmlSchemaFreeWildcard(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue exports_XML_SCHEMA_WHITESPACE_UNKNOWN_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_WHITESPACE_UNKNOWN));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_WHITESPACE_PRESERVE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_WHITESPACE_PRESERVE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_WHITESPACE_REPLACE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_WHITESPACE_REPLACE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue exports_XML_SCHEMA_WHITESPACE_COLLAPSE_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_SCHEMA_WHITESPACE_COLLAPSE));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap_xmlSchemaInitTypes(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaInitTypes.");
  
  result = (int)xmlSchemaInitTypes();
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaCleanupTypes(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaCleanupTypes.");
  
  xmlSchemaCleanupTypes();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaGetPredefinedType(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlSchemaTypePtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaGetPredefinedType.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaGetPredefinedType" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaGetPredefinedType" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlSchemaTypePtr)xmlSchemaGetPredefinedType((unsigned char const *)arg1,(unsigned char const *)arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValidatePredefinedType(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaTypePtr arg1 = (xmlSchemaTypePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlSchemaValPtr *arg3 = (xmlSchemaValPtr *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValidatePredefinedType.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValidatePredefinedType" "', argument " "1"" of type '" "xmlSchemaTypePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaTypePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaValidatePredefinedType" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSchemaValidatePredefinedType" "', argument " "3"" of type '" "xmlSchemaValPtr *""'"); 
  }
  arg3 = reinterpret_cast< xmlSchemaValPtr * >(argp3);result = (int)xmlSchemaValidatePredefinedType(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValPredefTypeNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaTypePtr arg1 = (xmlSchemaTypePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlSchemaValPtr *arg3 = (xmlSchemaValPtr *) 0 ;
  xmlNodePtr arg4 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  void *arg40 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValPredefTypeNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValPredefTypeNode" "', argument " "1"" of type '" "xmlSchemaTypePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaTypePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaValPredefTypeNode" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSchemaValPredefTypeNode" "', argument " "3"" of type '" "xmlSchemaValPtr *""'"); 
  }
  arg3 = reinterpret_cast< xmlSchemaValPtr * >(argp3);res4 = SWIG_ConvertPtr(args[3], &arg40, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res4)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[3], &arg40, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[3], &arg40, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[3], &arg40, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[3], &arg40, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method 'xmlSchemaValPredefTypeNode', argument 4 of type 'xmlNodePtr'"); 
    }
  }
  
  arg4 = ((xmlNodePtr) arg40);result = (int)xmlSchemaValPredefTypeNode(arg1,(unsigned char const *)arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValidateFacet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaTypePtr arg1 = (xmlSchemaTypePtr) 0 ;
  xmlSchemaFacetPtr arg2 = (xmlSchemaFacetPtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlSchemaValPtr arg4 = (xmlSchemaValPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValidateFacet.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValidateFacet" "', argument " "1"" of type '" "xmlSchemaTypePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaTypePtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaValidateFacet" "', argument " "2"" of type '" "xmlSchemaFacetPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaFacetPtr >(argp2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSchemaValidateFacet" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSchemaValidateFacet" "', argument " "4"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg4 = reinterpret_cast< xmlSchemaValPtr >(argp4);result = (int)xmlSchemaValidateFacet(arg1,arg2,(unsigned char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValidateFacetWhtsp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaFacetPtr arg1 = (xmlSchemaFacetPtr) 0 ;
  xmlSchemaWhitespaceValueType arg2 ;
  xmlSchemaValType arg3 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlSchemaValPtr arg5 = (xmlSchemaValPtr) 0 ;
  xmlSchemaWhitespaceValueType arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValidateFacetWhtsp.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValidateFacetWhtsp" "', argument " "1"" of type '" "xmlSchemaFacetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaFacetPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlSchemaValidateFacetWhtsp" "', argument " "2"" of type '" "xmlSchemaWhitespaceValueType""'");
  } 
  arg2 = static_cast< xmlSchemaWhitespaceValueType >(val2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSchemaValidateFacetWhtsp" "', argument " "3"" of type '" "xmlSchemaValType""'");
  } 
  arg3 = static_cast< xmlSchemaValType >(val3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSchemaValidateFacetWhtsp" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }res5 = SWIG_ConvertPtr(args[4], &argp5,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlSchemaValidateFacetWhtsp" "', argument " "5"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg5 = reinterpret_cast< xmlSchemaValPtr >(argp5);ecode6 = SWIG_AsVal_int(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xmlSchemaValidateFacetWhtsp" "', argument " "6"" of type '" "xmlSchemaWhitespaceValueType""'");
  } 
  arg6 = static_cast< xmlSchemaWhitespaceValueType >(val6);result = (int)xmlSchemaValidateFacetWhtsp(arg1,arg2,arg3,(unsigned char const *)arg4,arg5,arg6);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaFreeValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValPtr arg1 = (xmlSchemaValPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaFreeValue.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaFreeValue" "', argument " "1"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValPtr >(argp1);xmlSchemaFreeValue(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaNewFacet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaFacetPtr result;
  
  if (args.Length() < 0 || args.Length() > 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaNewFacet.");
  
  result = (xmlSchemaFacetPtr)xmlSchemaNewFacet();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaCheckFacet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaFacetPtr arg1 = (xmlSchemaFacetPtr) 0 ;
  xmlSchemaTypePtr arg2 = (xmlSchemaTypePtr) 0 ;
  xmlSchemaParserCtxtPtr arg3 = (xmlSchemaParserCtxtPtr) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaCheckFacet.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaCheckFacet" "', argument " "1"" of type '" "xmlSchemaFacetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaFacetPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaCheckFacet" "', argument " "2"" of type '" "xmlSchemaTypePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaTypePtr >(argp2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlSchemaParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSchemaCheckFacet" "', argument " "3"" of type '" "xmlSchemaParserCtxtPtr""'"); 
  }
  arg3 = reinterpret_cast< xmlSchemaParserCtxtPtr >(argp3);if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSchemaCheckFacet" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (int)xmlSchemaCheckFacet(arg1,arg2,arg3,(unsigned char const *)arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaFreeFacet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaFacetPtr arg1 = (xmlSchemaFacetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaFreeFacet.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaFreeFacet" "', argument " "1"" of type '" "xmlSchemaFacetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaFacetPtr >(argp1);xmlSchemaFreeFacet(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaCompareValues(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValPtr arg1 = (xmlSchemaValPtr) 0 ;
  xmlSchemaValPtr arg2 = (xmlSchemaValPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaCompareValues.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaCompareValues" "', argument " "1"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaCompareValues" "', argument " "2"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaValPtr >(argp2);result = (int)xmlSchemaCompareValues(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaGetBuiltInListSimpleTypeItemType(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaTypePtr arg1 = (xmlSchemaTypePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaTypePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaGetBuiltInListSimpleTypeItemType.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaGetBuiltInListSimpleTypeItemType" "', argument " "1"" of type '" "xmlSchemaTypePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaTypePtr >(argp1);result = (xmlSchemaTypePtr)xmlSchemaGetBuiltInListSimpleTypeItemType(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValidateListSimpleTypeFacet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaFacetPtr arg1 = (xmlSchemaFacetPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  unsigned long arg3 ;
  unsigned long *arg4 = (unsigned long *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  unsigned long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValidateListSimpleTypeFacet.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValidateListSimpleTypeFacet" "', argument " "1"" of type '" "xmlSchemaFacetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaFacetPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaValidateListSimpleTypeFacet" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_unsigned_SS_long(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSchemaValidateListSimpleTypeFacet" "', argument " "3"" of type '" "unsigned long""'");
  } 
  arg3 = static_cast< unsigned long >(val3);res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSchemaValidateListSimpleTypeFacet" "', argument " "4"" of type '" "unsigned long *""'"); 
  }
  arg4 = reinterpret_cast< unsigned long * >(argp4);result = (int)xmlSchemaValidateListSimpleTypeFacet(arg1,(unsigned char const *)arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaGetBuiltInType(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  xmlSchemaTypePtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaGetBuiltInType.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlSchemaGetBuiltInType" "', argument " "1"" of type '" "xmlSchemaValType""'");
  } 
  arg1 = static_cast< xmlSchemaValType >(val1);result = (xmlSchemaTypePtr)xmlSchemaGetBuiltInType(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaIsBuiltInTypeFacet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaTypePtr arg1 = (xmlSchemaTypePtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaIsBuiltInTypeFacet.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaIsBuiltInTypeFacet" "', argument " "1"" of type '" "xmlSchemaTypePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaTypePtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlSchemaIsBuiltInTypeFacet" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlSchemaIsBuiltInTypeFacet(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaCollapseString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaCollapseString.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaCollapseString" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlChar *)xmlSchemaCollapseString((unsigned char const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaWhiteSpaceReplace(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaWhiteSpaceReplace.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaWhiteSpaceReplace" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }result = (xmlChar *)xmlSchemaWhiteSpaceReplace((unsigned char const *)arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaGetFacetValueAsULong(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaFacetPtr arg1 = (xmlSchemaFacetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaGetFacetValueAsULong.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaGetFacetValueAsULong" "', argument " "1"" of type '" "xmlSchemaFacetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaFacetPtr >(argp1);result = (unsigned long)xmlSchemaGetFacetValueAsULong(arg1);
  jsresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValidateLengthFacet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaTypePtr arg1 = (xmlSchemaTypePtr) 0 ;
  xmlSchemaFacetPtr arg2 = (xmlSchemaFacetPtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlSchemaValPtr arg4 = (xmlSchemaValPtr) 0 ;
  unsigned long *arg5 = (unsigned long *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValidateLengthFacet.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValidateLengthFacet" "', argument " "1"" of type '" "xmlSchemaTypePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaTypePtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaValidateLengthFacet" "', argument " "2"" of type '" "xmlSchemaFacetPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaFacetPtr >(argp2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSchemaValidateLengthFacet" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSchemaValidateLengthFacet" "', argument " "4"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg4 = reinterpret_cast< xmlSchemaValPtr >(argp4);res5 = SWIG_ConvertPtr(args[4], &argp5,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlSchemaValidateLengthFacet" "', argument " "5"" of type '" "unsigned long *""'"); 
  }
  arg5 = reinterpret_cast< unsigned long * >(argp5);result = (int)xmlSchemaValidateLengthFacet(arg1,arg2,(unsigned char const *)arg3,arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValidateLengthFacetWhtsp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaFacetPtr arg1 = (xmlSchemaFacetPtr) 0 ;
  xmlSchemaValType arg2 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlSchemaValPtr arg4 = (xmlSchemaValPtr) 0 ;
  unsigned long *arg5 = (unsigned long *) 0 ;
  xmlSchemaWhitespaceValueType arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValidateLengthFacetWhtsp.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaFacet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValidateLengthFacetWhtsp" "', argument " "1"" of type '" "xmlSchemaFacetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaFacetPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlSchemaValidateLengthFacetWhtsp" "', argument " "2"" of type '" "xmlSchemaValType""'");
  } 
  arg2 = static_cast< xmlSchemaValType >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSchemaValidateLengthFacetWhtsp" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }res4 = SWIG_ConvertPtr(args[3], &argp4,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlSchemaValidateLengthFacetWhtsp" "', argument " "4"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg4 = reinterpret_cast< xmlSchemaValPtr >(argp4);res5 = SWIG_ConvertPtr(args[4], &argp5,SWIGTYPE_p_unsigned_long, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlSchemaValidateLengthFacetWhtsp" "', argument " "5"" of type '" "unsigned long *""'"); 
  }
  arg5 = reinterpret_cast< unsigned long * >(argp5);ecode6 = SWIG_AsVal_int(args[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "xmlSchemaValidateLengthFacetWhtsp" "', argument " "6"" of type '" "xmlSchemaWhitespaceValueType""'");
  } 
  arg6 = static_cast< xmlSchemaWhitespaceValueType >(val6);result = (int)xmlSchemaValidateLengthFacetWhtsp(arg1,arg2,(unsigned char const *)arg3,arg4,arg5,arg6);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValPredefTypeNodeNoNorm(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaTypePtr arg1 = (xmlSchemaTypePtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlSchemaValPtr *arg3 = (xmlSchemaValPtr *) 0 ;
  xmlNodePtr arg4 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  void *arg40 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValPredefTypeNodeNoNorm.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaType, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValPredefTypeNodeNoNorm" "', argument " "1"" of type '" "xmlSchemaTypePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaTypePtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaValPredefTypeNodeNoNorm" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSchemaValPredefTypeNodeNoNorm" "', argument " "3"" of type '" "xmlSchemaValPtr *""'"); 
  }
  arg3 = reinterpret_cast< xmlSchemaValPtr * >(argp3);res4 = SWIG_ConvertPtr(args[3], &arg40, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res4)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[3], &arg40, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[3], &arg40, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[3], &arg40, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[3], &arg40, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method 'xmlSchemaValPredefTypeNodeNoNorm', argument 4 of type 'xmlNodePtr'"); 
    }
  }
  
  arg4 = ((xmlNodePtr) arg40);result = (int)xmlSchemaValPredefTypeNodeNoNorm(arg1,(unsigned char const *)arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaGetCanonValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValPtr arg1 = (xmlSchemaValPtr) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaGetCanonValue.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaGetCanonValue" "', argument " "1"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaGetCanonValue" "', argument " "2"" of type '" "xmlChar const **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);result = (int)xmlSchemaGetCanonValue(arg1,(unsigned char const **)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaGetCanonValueWhtsp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValPtr arg1 = (xmlSchemaValPtr) 0 ;
  xmlChar **arg2 = (xmlChar **) 0 ;
  xmlSchemaWhitespaceValueType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaGetCanonValueWhtsp.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaGetCanonValueWhtsp" "', argument " "1"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaGetCanonValueWhtsp" "', argument " "2"" of type '" "xmlChar const **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlSchemaGetCanonValueWhtsp" "', argument " "3"" of type '" "xmlSchemaWhitespaceValueType""'");
  } 
  arg3 = static_cast< xmlSchemaWhitespaceValueType >(val3);result = (int)xmlSchemaGetCanonValueWhtsp(arg1,(unsigned char const **)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValueAppend(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValPtr arg1 = (xmlSchemaValPtr) 0 ;
  xmlSchemaValPtr arg2 = (xmlSchemaValPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValueAppend.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValueAppend" "', argument " "1"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValPtr >(argp1);res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaValueAppend" "', argument " "2"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSchemaValPtr >(argp2);result = (int)xmlSchemaValueAppend(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValueGetNext(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValPtr arg1 = (xmlSchemaValPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaValPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValueGetNext.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValueGetNext" "', argument " "1"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValPtr >(argp1);result = (xmlSchemaValPtr)xmlSchemaValueGetNext(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValueGetAsString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValPtr arg1 = (xmlSchemaValPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlChar *result = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValueGetAsString.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValueGetAsString" "', argument " "1"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValPtr >(argp1);result = (xmlChar *)xmlSchemaValueGetAsString(arg1);
  {
    jsresult = SWIGV8_STRING_NEW2((char*)result, xmlStrlen(result));
    
    // int source_chars = xmlUTF8Strlen(result);
    // int target_chars = jsresult->ToString()->Length();
    
    // int source_bytes = xmlStrlen(result);
    // int target_bytes = SWIGV8_UTF8_LENGTH(jsresult->ToString());
    
    // if (source_chars != target_chars || source_bytes != target_bytes) {
    //   SWIG_exception_fail(0, "Error writing to String");
    // }
  }
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaValueGetAsBoolean(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValPtr arg1 = (xmlSchemaValPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaValueGetAsBoolean.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaValueGetAsBoolean" "', argument " "1"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValPtr >(argp1);result = (int)xmlSchemaValueGetAsBoolean(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaNewStringValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValType arg1 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlSchemaValPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaNewStringValue.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlSchemaNewStringValue" "', argument " "1"" of type '" "xmlSchemaValType""'");
  } 
  arg1 = static_cast< xmlSchemaValType >(val1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaNewStringValue" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlSchemaValPtr)xmlSchemaNewStringValue(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaNewNOTATIONValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlSchemaValPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaNewNOTATIONValue.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaNewNOTATIONValue" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaNewNOTATIONValue" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlSchemaValPtr)xmlSchemaNewNOTATIONValue((unsigned char const *)arg1,(unsigned char const *)arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaNewQNameValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlSchemaValPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaNewQNameValue.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaNewQNameValue" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlSchemaNewQNameValue" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (xmlSchemaValPtr)xmlSchemaNewQNameValue((unsigned char const *)arg1,(unsigned char const *)arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaCompareValuesWhtsp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValPtr arg1 = (xmlSchemaValPtr) 0 ;
  xmlSchemaWhitespaceValueType arg2 ;
  xmlSchemaValPtr arg3 = (xmlSchemaValPtr) 0 ;
  xmlSchemaWhitespaceValueType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaCompareValuesWhtsp.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaCompareValuesWhtsp" "', argument " "1"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlSchemaCompareValuesWhtsp" "', argument " "2"" of type '" "xmlSchemaWhitespaceValueType""'");
  } 
  arg2 = static_cast< xmlSchemaWhitespaceValueType >(val2);res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlSchemaCompareValuesWhtsp" "', argument " "3"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg3 = reinterpret_cast< xmlSchemaValPtr >(argp3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlSchemaCompareValuesWhtsp" "', argument " "4"" of type '" "xmlSchemaWhitespaceValueType""'");
  } 
  arg4 = static_cast< xmlSchemaWhitespaceValueType >(val4);result = (int)xmlSchemaCompareValuesWhtsp(arg1,arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaCopyValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValPtr arg1 = (xmlSchemaValPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaValPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaCopyValue.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaCopyValue" "', argument " "1"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValPtr >(argp1);result = (xmlSchemaValPtr)xmlSchemaCopyValue(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlSchemaGetValType(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSchemaValPtr arg1 = (xmlSchemaValPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlSchemaValType result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaGetValType.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSchemaVal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSchemaGetValType" "', argument " "1"" of type '" "xmlSchemaValPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlSchemaValPtr >(argp1);result = (xmlSchemaValType)xmlSchemaGetValType(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsAegeanNumbers(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsAegeanNumbers.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsAegeanNumbers" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsAegeanNumbers(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsAlphabeticPresentationForms(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsAlphabeticPresentationForms.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsAlphabeticPresentationForms" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsAlphabeticPresentationForms(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsArabic(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsArabic.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsArabic" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsArabic(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsArabicPresentationFormsA(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsArabicPresentationFormsA.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsArabicPresentationFormsA" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsArabicPresentationFormsA(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsArabicPresentationFormsB(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsArabicPresentationFormsB.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsArabicPresentationFormsB" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsArabicPresentationFormsB(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsArmenian(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsArmenian.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsArmenian" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsArmenian(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsArrows(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsArrows.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsArrows" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsArrows(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsBasicLatin(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsBasicLatin.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsBasicLatin" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsBasicLatin(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsBengali(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsBengali.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsBengali" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsBengali(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsBlockElements(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsBlockElements.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsBlockElements" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsBlockElements(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsBopomofo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsBopomofo.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsBopomofo" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsBopomofo(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsBopomofoExtended(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsBopomofoExtended.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsBopomofoExtended" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsBopomofoExtended(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsBoxDrawing(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsBoxDrawing.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsBoxDrawing" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsBoxDrawing(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsBraillePatterns(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsBraillePatterns.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsBraillePatterns" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsBraillePatterns(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsBuhid(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsBuhid.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsBuhid" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsBuhid(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsByzantineMusicalSymbols(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsByzantineMusicalSymbols.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsByzantineMusicalSymbols" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsByzantineMusicalSymbols(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCJKCompatibility(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCJKCompatibility.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCJKCompatibility" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCJKCompatibility(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCJKCompatibilityForms(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCJKCompatibilityForms.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCJKCompatibilityForms" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCJKCompatibilityForms(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCJKCompatibilityIdeographs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCJKCompatibilityIdeographs.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCJKCompatibilityIdeographs" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCJKCompatibilityIdeographs(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCJKCompatibilityIdeographsSupplement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCJKCompatibilityIdeographsSupplement.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCJKCompatibilityIdeographsSupplement" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCJKCompatibilityIdeographsSupplement(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCJKRadicalsSupplement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCJKRadicalsSupplement.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCJKRadicalsSupplement" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCJKRadicalsSupplement(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCJKSymbolsandPunctuation(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCJKSymbolsandPunctuation.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCJKSymbolsandPunctuation" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCJKSymbolsandPunctuation(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCJKUnifiedIdeographs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCJKUnifiedIdeographs.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCJKUnifiedIdeographs" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCJKUnifiedIdeographs(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCJKUnifiedIdeographsExtensionA(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCJKUnifiedIdeographsExtensionA.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCJKUnifiedIdeographsExtensionA" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCJKUnifiedIdeographsExtensionA(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCJKUnifiedIdeographsExtensionB(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCJKUnifiedIdeographsExtensionB.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCJKUnifiedIdeographsExtensionB" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCJKUnifiedIdeographsExtensionB(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCherokee(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCherokee.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCherokee" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCherokee(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCombiningDiacriticalMarks(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCombiningDiacriticalMarks.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCombiningDiacriticalMarks" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCombiningDiacriticalMarks(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCombiningDiacriticalMarksforSymbols(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCombiningDiacriticalMarksforSymbols.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCombiningDiacriticalMarksforSymbols" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCombiningDiacriticalMarksforSymbols(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCombiningHalfMarks(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCombiningHalfMarks.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCombiningHalfMarks" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCombiningHalfMarks(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCombiningMarksforSymbols(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCombiningMarksforSymbols.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCombiningMarksforSymbols" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCombiningMarksforSymbols(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsControlPictures(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsControlPictures.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsControlPictures" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsControlPictures(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCurrencySymbols(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCurrencySymbols.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCurrencySymbols" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCurrencySymbols(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCypriotSyllabary(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCypriotSyllabary.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCypriotSyllabary" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCypriotSyllabary(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCyrillic(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCyrillic.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCyrillic" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCyrillic(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCyrillicSupplement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCyrillicSupplement.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCyrillicSupplement" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCyrillicSupplement(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsDeseret(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsDeseret.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsDeseret" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsDeseret(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsDevanagari(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsDevanagari.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsDevanagari" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsDevanagari(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsDingbats(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsDingbats.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsDingbats" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsDingbats(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsEnclosedAlphanumerics(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsEnclosedAlphanumerics.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsEnclosedAlphanumerics" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsEnclosedAlphanumerics(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsEnclosedCJKLettersandMonths(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsEnclosedCJKLettersandMonths.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsEnclosedCJKLettersandMonths" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsEnclosedCJKLettersandMonths(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsEthiopic(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsEthiopic.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsEthiopic" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsEthiopic(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsGeneralPunctuation(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsGeneralPunctuation.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsGeneralPunctuation" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsGeneralPunctuation(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsGeometricShapes(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsGeometricShapes.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsGeometricShapes" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsGeometricShapes(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsGeorgian(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsGeorgian.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsGeorgian" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsGeorgian(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsGothic(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsGothic.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsGothic" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsGothic(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsGreek(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsGreek.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsGreek" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsGreek(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsGreekExtended(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsGreekExtended.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsGreekExtended" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsGreekExtended(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsGreekandCoptic(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsGreekandCoptic.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsGreekandCoptic" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsGreekandCoptic(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsGujarati(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsGujarati.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsGujarati" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsGujarati(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsGurmukhi(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsGurmukhi.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsGurmukhi" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsGurmukhi(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsHalfwidthandFullwidthForms(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsHalfwidthandFullwidthForms.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsHalfwidthandFullwidthForms" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsHalfwidthandFullwidthForms(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsHangulCompatibilityJamo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsHangulCompatibilityJamo.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsHangulCompatibilityJamo" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsHangulCompatibilityJamo(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsHangulJamo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsHangulJamo.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsHangulJamo" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsHangulJamo(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsHangulSyllables(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsHangulSyllables.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsHangulSyllables" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsHangulSyllables(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsHanunoo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsHanunoo.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsHanunoo" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsHanunoo(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsHebrew(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsHebrew.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsHebrew" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsHebrew(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsHighPrivateUseSurrogates(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsHighPrivateUseSurrogates.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsHighPrivateUseSurrogates" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsHighPrivateUseSurrogates(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsHighSurrogates(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsHighSurrogates.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsHighSurrogates" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsHighSurrogates(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsHiragana(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsHiragana.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsHiragana" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsHiragana(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsIPAExtensions(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsIPAExtensions.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsIPAExtensions" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsIPAExtensions(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsIdeographicDescriptionCharacters(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsIdeographicDescriptionCharacters.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsIdeographicDescriptionCharacters" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsIdeographicDescriptionCharacters(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsKanbun(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsKanbun.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsKanbun" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsKanbun(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsKangxiRadicals(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsKangxiRadicals.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsKangxiRadicals" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsKangxiRadicals(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsKannada(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsKannada.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsKannada" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsKannada(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsKatakana(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsKatakana.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsKatakana" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsKatakana(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsKatakanaPhoneticExtensions(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsKatakanaPhoneticExtensions.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsKatakanaPhoneticExtensions" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsKatakanaPhoneticExtensions(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsKhmer(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsKhmer.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsKhmer" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsKhmer(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsKhmerSymbols(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsKhmerSymbols.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsKhmerSymbols" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsKhmerSymbols(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsLao(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsLao.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsLao" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsLao(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsLatin1Supplement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsLatin1Supplement.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsLatin1Supplement" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsLatin1Supplement(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsLatinExtendedA(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsLatinExtendedA.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsLatinExtendedA" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsLatinExtendedA(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsLatinExtendedB(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsLatinExtendedB.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsLatinExtendedB" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsLatinExtendedB(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsLatinExtendedAdditional(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsLatinExtendedAdditional.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsLatinExtendedAdditional" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsLatinExtendedAdditional(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsLetterlikeSymbols(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsLetterlikeSymbols.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsLetterlikeSymbols" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsLetterlikeSymbols(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsLimbu(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsLimbu.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsLimbu" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsLimbu(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsLinearBIdeograms(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsLinearBIdeograms.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsLinearBIdeograms" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsLinearBIdeograms(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsLinearBSyllabary(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsLinearBSyllabary.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsLinearBSyllabary" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsLinearBSyllabary(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsLowSurrogates(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsLowSurrogates.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsLowSurrogates" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsLowSurrogates(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsMalayalam(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsMalayalam.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsMalayalam" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsMalayalam(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsMathematicalAlphanumericSymbols(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsMathematicalAlphanumericSymbols.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsMathematicalAlphanumericSymbols" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsMathematicalAlphanumericSymbols(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsMathematicalOperators(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsMathematicalOperators.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsMathematicalOperators" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsMathematicalOperators(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsMiscellaneousMathematicalSymbolsA(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsMiscellaneousMathematicalSymbolsA.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsMiscellaneousMathematicalSymbolsA" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsMiscellaneousMathematicalSymbolsA(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsMiscellaneousMathematicalSymbolsB(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsMiscellaneousMathematicalSymbolsB.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsMiscellaneousMathematicalSymbolsB" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsMiscellaneousMathematicalSymbolsB(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsMiscellaneousSymbols(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsMiscellaneousSymbols.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsMiscellaneousSymbols" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsMiscellaneousSymbols(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsMiscellaneousSymbolsandArrows(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsMiscellaneousSymbolsandArrows.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsMiscellaneousSymbolsandArrows" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsMiscellaneousSymbolsandArrows(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsMiscellaneousTechnical(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsMiscellaneousTechnical.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsMiscellaneousTechnical" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsMiscellaneousTechnical(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsMongolian(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsMongolian.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsMongolian" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsMongolian(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsMusicalSymbols(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsMusicalSymbols.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsMusicalSymbols" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsMusicalSymbols(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsMyanmar(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsMyanmar.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsMyanmar" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsMyanmar(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsNumberForms(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsNumberForms.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsNumberForms" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsNumberForms(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsOgham(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsOgham.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsOgham" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsOgham(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsOldItalic(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsOldItalic.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsOldItalic" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsOldItalic(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsOpticalCharacterRecognition(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsOpticalCharacterRecognition.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsOpticalCharacterRecognition" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsOpticalCharacterRecognition(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsOriya(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsOriya.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsOriya" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsOriya(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsOsmanya(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsOsmanya.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsOsmanya" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsOsmanya(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsPhoneticExtensions(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsPhoneticExtensions.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsPhoneticExtensions" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsPhoneticExtensions(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsPrivateUse(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsPrivateUse.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsPrivateUse" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsPrivateUse(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsPrivateUseArea(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsPrivateUseArea.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsPrivateUseArea" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsPrivateUseArea(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsRunic(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsRunic.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsRunic" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsRunic(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsShavian(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsShavian.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsShavian" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsShavian(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsSinhala(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsSinhala.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsSinhala" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsSinhala(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsSmallFormVariants(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsSmallFormVariants.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsSmallFormVariants" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsSmallFormVariants(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsSpacingModifierLetters(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsSpacingModifierLetters.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsSpacingModifierLetters" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsSpacingModifierLetters(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsSpecials(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsSpecials.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsSpecials" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsSpecials(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsSuperscriptsandSubscripts(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsSuperscriptsandSubscripts.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsSuperscriptsandSubscripts" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsSuperscriptsandSubscripts(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsSupplementalArrowsA(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsSupplementalArrowsA.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsSupplementalArrowsA" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsSupplementalArrowsA(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsSupplementalArrowsB(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsSupplementalArrowsB.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsSupplementalArrowsB" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsSupplementalArrowsB(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsSupplementalMathematicalOperators(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsSupplementalMathematicalOperators.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsSupplementalMathematicalOperators" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsSupplementalMathematicalOperators(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsSupplementaryPrivateUseAreaA(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsSupplementaryPrivateUseAreaA.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsSupplementaryPrivateUseAreaA" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsSupplementaryPrivateUseAreaA(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsSupplementaryPrivateUseAreaB(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsSupplementaryPrivateUseAreaB.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsSupplementaryPrivateUseAreaB" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsSupplementaryPrivateUseAreaB(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsSyriac(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsSyriac.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsSyriac" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsSyriac(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsTagalog(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsTagalog.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsTagalog" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsTagalog(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsTagbanwa(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsTagbanwa.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsTagbanwa" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsTagbanwa(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsTags(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsTags.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsTags" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsTags(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsTaiLe(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsTaiLe.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsTaiLe" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsTaiLe(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsTaiXuanJingSymbols(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsTaiXuanJingSymbols.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsTaiXuanJingSymbols" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsTaiXuanJingSymbols(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsTamil(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsTamil.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsTamil" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsTamil(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsTelugu(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsTelugu.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsTelugu" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsTelugu(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsThaana(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsThaana.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsThaana" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsThaana(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsThai(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsThai.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsThai" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsThai(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsTibetan(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsTibetan.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsTibetan" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsTibetan(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsUgaritic(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsUgaritic.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsUgaritic" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsUgaritic(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsUnifiedCanadianAboriginalSyllabics(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsUnifiedCanadianAboriginalSyllabics.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsUnifiedCanadianAboriginalSyllabics" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsUnifiedCanadianAboriginalSyllabics(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsVariationSelectors(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsVariationSelectors.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsVariationSelectors" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsVariationSelectors(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsVariationSelectorsSupplement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsVariationSelectorsSupplement.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsVariationSelectorsSupplement" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsVariationSelectorsSupplement(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsYiRadicals(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsYiRadicals.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsYiRadicals" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsYiRadicals(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsYiSyllables(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsYiSyllables.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsYiSyllables" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsYiSyllables(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsYijingHexagramSymbols(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsYijingHexagramSymbols.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsYijingHexagramSymbols" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsYijingHexagramSymbols(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsBlock(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  char *arg2 = (char *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsBlock.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsBlock" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlUCSIsBlock" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (int)xmlUCSIsBlock(arg1,(char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatC(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatC.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatC" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatC(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatCc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatCc.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatCc" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatCc(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatCf(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatCf.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatCf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatCf(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatCo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatCo.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatCo" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatCo(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatCs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatCs.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatCs" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatCs(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatL(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatL.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatL" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatL(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatLl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatLl.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatLl" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatLl(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatLm(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatLm.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatLm" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatLm(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatLo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatLo.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatLo" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatLo(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatLt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatLt.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatLt" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatLt(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatLu(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatLu.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatLu" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatLu(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatM(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatM.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatM" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatM(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatMc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatMc.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatMc" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatMc(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatMe(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatMe.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatMe" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatMe(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatMn(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatMn.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatMn" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatMn(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatN(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatN.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatN" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatN(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatNd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatNd.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatNd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatNd(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatNl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatNl.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatNl" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatNl(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatNo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatNo.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatNo" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatNo(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatP(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatP.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatP" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatP(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatPc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatPc.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatPc" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatPc(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatPd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatPd.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatPd" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatPd(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatPe(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatPe.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatPe" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatPe(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatPf(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatPf.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatPf" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatPf(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatPi(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatPi.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatPi" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatPi(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatPo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatPo.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatPo" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatPo(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatPs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatPs.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatPs" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatPs(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatS(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatS.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatS" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatS(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatSc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatSc.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatSc" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatSc(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatSk(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatSk.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatSk" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatSk(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatSm(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatSm.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatSm" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatSm(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatSo(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatSo.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatSo" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatSo(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatZ(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatZ.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatZ" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatZ(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatZl(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatZl.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatZl" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatZl(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatZp(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatZp.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatZp" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatZp(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCatZs(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCatZs.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCatZs" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);result = (int)xmlUCSIsCatZs(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlUCSIsCat(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  char *arg2 = (char *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlUCSIsCat.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlUCSIsCat" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlUCSIsCat" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (int)xmlUCSIsCat(arg1,(char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewTextWriter(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferPtr arg1 = (xmlOutputBufferPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlTextWriterPtr result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewTextWriter.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlOutputBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewTextWriter" "', argument " "1"" of type '" "xmlOutputBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlOutputBufferPtr >(argp1);result = (xmlTextWriterPtr)xmlNewTextWriter(arg1);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewTextWriterFilename(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlTextWriterPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewTextWriterFilename.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(args[0])) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(args[0]).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewTextWriterFilename" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlNewTextWriterFilename" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlTextWriterPtr)xmlNewTextWriterFilename((char const *)arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  // free(arg1);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewTextWriterMemory(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferPtr arg1 = (xmlBufferPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlTextWriterPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewTextWriterMemory.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewTextWriterMemory" "', argument " "1"" of type '" "xmlBufferPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlBufferPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlNewTextWriterMemory" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlTextWriterPtr)xmlNewTextWriterMemory(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewTextWriterPushParser(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlTextWriterPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewTextWriterPushParser.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewTextWriterPushParser" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlNewTextWriterPushParser" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlTextWriterPtr)xmlNewTextWriterPushParser(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewTextWriterDoc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr *arg1 = (xmlDocPtr *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  xmlTextWriterPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewTextWriterDoc.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNewTextWriterDoc" "', argument " "1"" of type '" "xmlDocPtr *""'"); 
  }
  arg1 = reinterpret_cast< xmlDocPtr * >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlNewTextWriterDoc" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (xmlTextWriterPtr)xmlNewTextWriterDoc(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNewTextWriterTree(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  int arg3 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int val3 ;
  int ecode3 = 0 ;
  xmlTextWriterPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewTextWriterTree.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewTextWriterTree', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlNewTextWriterTree', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlNewTextWriterTree" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (xmlTextWriterPtr)xmlNewTextWriterTree(arg1,arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlFreeTextWriter(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlFreeTextWriter.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlFreeTextWriter" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);xmlFreeTextWriter(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterStartDocument(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterStartDocument.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterStartDocument" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterStartDocument" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterStartDocument" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlTextWriterStartDocument" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }result = (int)xmlTextWriterStartDocument(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  // free(arg3);
  // free(arg4);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterEndDocument(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterEndDocument.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterEndDocument" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);result = (int)xmlTextWriterEndDocument(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterStartComment(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterStartComment.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterStartComment" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);result = (int)xmlTextWriterStartComment(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterEndComment(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterEndComment.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterEndComment" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);result = (int)xmlTextWriterEndComment(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteFormatComment(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteFormatComment.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteFormatComment" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteFormatComment" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (int)xmlTextWriterWriteFormatComment(arg1,(char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteComment(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteComment.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteComment" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteComment" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlTextWriterWriteComment(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterStartElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterStartElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterStartElement" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterStartElement" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlTextWriterStartElement(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterStartElementNS(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterStartElementNS.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterStartElementNS" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterStartElementNS" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterStartElementNS" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlTextWriterStartElementNS" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (int)xmlTextWriterStartElementNS(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterEndElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterEndElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterEndElement" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);result = (int)xmlTextWriterEndElement(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterFullEndElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterFullEndElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterFullEndElement" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);result = (int)xmlTextWriterFullEndElement(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteFormatElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  char *arg3 = (char *) 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteFormatElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteFormatElement" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteFormatElement" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteFormatElement" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }result = (int)xmlTextWriterWriteFormatElement(arg1,(unsigned char const *)arg2,(char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  // free(arg3);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteElement" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteElement" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteElement" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (int)xmlTextWriterWriteElement(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteFormatElementNS(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  char *arg5 = (char *) 0 ;
  void *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteFormatElementNS.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteFormatElementNS" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteFormatElementNS" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteFormatElementNS" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlTextWriterWriteFormatElementNS" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else if (node::Buffer::HasInstance(args[4])) {
    arg5 = node::Buffer::Data(Nan::To<v8::Object>(args[4]).ToLocalChecked());
    // printf("data: %s - %i\n", arg5, strlen(arg5));
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlTextWriterWriteFormatElementNS" "', argument " "5"" of type '" "char const *""'");
    }
    
    arg5 = reinterpret_cast< char * >(buf5);
  }result = (int)xmlTextWriterWriteFormatElementNS(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,(char const *)arg5,arg6);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  // free(arg5);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteElementNS(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteElementNS.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteElementNS" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteElementNS" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteElementNS" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlTextWriterWriteElementNS" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlTextWriterWriteElementNS" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }result = (int)xmlTextWriterWriteElementNS(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,(unsigned char const *)arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteFormatRaw(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteFormatRaw.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteFormatRaw" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteFormatRaw" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (int)xmlTextWriterWriteFormatRaw(arg1,(char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteRawLen(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteRawLen.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteRawLen" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteRawLen" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlTextWriterWriteRawLen" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);result = (int)xmlTextWriterWriteRawLen(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteRaw(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteRaw.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteRaw" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteRaw" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlTextWriterWriteRaw(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteFormatString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteFormatString.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteFormatString" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteFormatString" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (int)xmlTextWriterWriteFormatString(arg1,(char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteString.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteString" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteString" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlTextWriterWriteString(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteBase64(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteBase64.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteBase64" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteBase64" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlTextWriterWriteBase64" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlTextWriterWriteBase64" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (int)xmlTextWriterWriteBase64(arg1,(char const *)arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteBinHex(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteBinHex.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteBinHex" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteBinHex" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlTextWriterWriteBinHex" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);ecode4 = SWIG_AsVal_int(args[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xmlTextWriterWriteBinHex" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);result = (int)xmlTextWriterWriteBinHex(arg1,(char const *)arg2,arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterStartAttribute(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterStartAttribute.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterStartAttribute" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterStartAttribute" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlTextWriterStartAttribute(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterStartAttributeNS(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterStartAttributeNS.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterStartAttributeNS" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterStartAttributeNS" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterStartAttributeNS" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlTextWriterStartAttributeNS" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (int)xmlTextWriterStartAttributeNS(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterEndAttribute(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterEndAttribute.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterEndAttribute" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);result = (int)xmlTextWriterEndAttribute(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteFormatAttribute(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  char *arg3 = (char *) 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteFormatAttribute.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteFormatAttribute" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteFormatAttribute" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteFormatAttribute" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }result = (int)xmlTextWriterWriteFormatAttribute(arg1,(unsigned char const *)arg2,(char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  // free(arg3);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteAttribute(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteAttribute.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteAttribute" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteAttribute" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteAttribute" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (int)xmlTextWriterWriteAttribute(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteFormatAttributeNS(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  char *arg5 = (char *) 0 ;
  void *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteFormatAttributeNS.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteFormatAttributeNS" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteFormatAttributeNS" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteFormatAttributeNS" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlTextWriterWriteFormatAttributeNS" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else if (node::Buffer::HasInstance(args[4])) {
    arg5 = node::Buffer::Data(Nan::To<v8::Object>(args[4]).ToLocalChecked());
    // printf("data: %s - %i\n", arg5, strlen(arg5));
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlTextWriterWriteFormatAttributeNS" "', argument " "5"" of type '" "char const *""'");
    }
    
    arg5 = reinterpret_cast< char * >(buf5);
  }result = (int)xmlTextWriterWriteFormatAttributeNS(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,(char const *)arg5,arg6);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  // free(arg5);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteAttributeNS(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteAttributeNS.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteAttributeNS" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteAttributeNS" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteAttributeNS" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlTextWriterWriteAttributeNS" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlTextWriterWriteAttributeNS" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }result = (int)xmlTextWriterWriteAttributeNS(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,(unsigned char const *)arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterStartPI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterStartPI.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterStartPI" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterStartPI" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlTextWriterStartPI(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterEndPI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterEndPI.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterEndPI" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);result = (int)xmlTextWriterEndPI(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteFormatPI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  char *arg3 = (char *) 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteFormatPI.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteFormatPI" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteFormatPI" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteFormatPI" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }result = (int)xmlTextWriterWriteFormatPI(arg1,(unsigned char const *)arg2,(char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  // free(arg3);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWritePI(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWritePI.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWritePI" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWritePI" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWritePI" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (int)xmlTextWriterWritePI(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterStartCDATA(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterStartCDATA.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterStartCDATA" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);result = (int)xmlTextWriterStartCDATA(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterEndCDATA(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterEndCDATA.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterEndCDATA" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);result = (int)xmlTextWriterEndCDATA(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteFormatCDATA(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteFormatCDATA.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteFormatCDATA" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else if (node::Buffer::HasInstance(args[1])) {
    arg2 = node::Buffer::Data(Nan::To<v8::Object>(args[1]).ToLocalChecked());
    // printf("data: %s - %i\n", arg2, strlen(arg2));
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteFormatCDATA" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }result = (int)xmlTextWriterWriteFormatCDATA(arg1,(char const *)arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteCDATA(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteCDATA.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteCDATA" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteCDATA" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlTextWriterWriteCDATA(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterStartDTD(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterStartDTD.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterStartDTD" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterStartDTD" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterStartDTD" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlTextWriterStartDTD" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (int)xmlTextWriterStartDTD(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterEndDTD(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterEndDTD.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterEndDTD" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);result = (int)xmlTextWriterEndDTD(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteFormatDTD(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  char *arg5 = (char *) 0 ;
  void *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteFormatDTD.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteFormatDTD" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteFormatDTD" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteFormatDTD" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlTextWriterWriteFormatDTD" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else if (node::Buffer::HasInstance(args[4])) {
    arg5 = node::Buffer::Data(Nan::To<v8::Object>(args[4]).ToLocalChecked());
    // printf("data: %s - %i\n", arg5, strlen(arg5));
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlTextWriterWriteFormatDTD" "', argument " "5"" of type '" "char const *""'");
    }
    
    arg5 = reinterpret_cast< char * >(buf5);
  }result = (int)xmlTextWriterWriteFormatDTD(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,(char const *)arg5,arg6);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  // free(arg5);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteDTD(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int result;
  
  if (args.Length() < 5 || args.Length() > 5) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteDTD.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteDTD" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteDTD" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteDTD" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlTextWriterWriteDTD" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlTextWriterWriteDTD" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }result = (int)xmlTextWriterWriteDTD(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,(unsigned char const *)arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterStartDTDElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterStartDTDElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterStartDTDElement" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterStartDTDElement" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlTextWriterStartDTDElement(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterEndDTDElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterEndDTDElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterEndDTDElement" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);result = (int)xmlTextWriterEndDTDElement(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteFormatDTDElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  char *arg3 = (char *) 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteFormatDTDElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteFormatDTDElement" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteFormatDTDElement" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteFormatDTDElement" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }result = (int)xmlTextWriterWriteFormatDTDElement(arg1,(unsigned char const *)arg2,(char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  // free(arg3);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteDTDElement(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteDTDElement.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteDTDElement" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteDTDElement" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteDTDElement" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (int)xmlTextWriterWriteDTDElement(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterStartDTDAttlist(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterStartDTDAttlist.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterStartDTDAttlist" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterStartDTDAttlist" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlTextWriterStartDTDAttlist(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterEndDTDAttlist(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterEndDTDAttlist.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterEndDTDAttlist" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);result = (int)xmlTextWriterEndDTDAttlist(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteFormatDTDAttlist(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  char *arg3 = (char *) 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteFormatDTDAttlist.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteFormatDTDAttlist" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteFormatDTDAttlist" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else if (node::Buffer::HasInstance(args[2])) {
    arg3 = node::Buffer::Data(Nan::To<v8::Object>(args[2]).ToLocalChecked());
    // printf("data: %s - %i\n", arg3, strlen(arg3));
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteFormatDTDAttlist" "', argument " "3"" of type '" "char const *""'");
    }
    
    arg3 = reinterpret_cast< char * >(buf3);
  }result = (int)xmlTextWriterWriteFormatDTDAttlist(arg1,(unsigned char const *)arg2,(char const *)arg3,arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  // free(arg3);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteDTDAttlist(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteDTDAttlist.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteDTDAttlist" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteDTDAttlist" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteDTDAttlist" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (int)xmlTextWriterWriteDTDAttlist(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterStartDTDEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  int arg2 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterStartDTDEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterStartDTDEntity" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlTextWriterStartDTDEntity" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterStartDTDEntity" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }result = (int)xmlTextWriterStartDTDEntity(arg1,arg2,(unsigned char const *)arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterEndDTDEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterEndDTDEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterEndDTDEntity" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);result = (int)xmlTextWriterEndDTDEntity(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteFormatDTDInternalEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  int arg2 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  char *arg4 = (char *) 0 ;
  void *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteFormatDTDInternalEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteFormatDTDInternalEntity" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlTextWriterWriteFormatDTDInternalEntity" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteFormatDTDInternalEntity" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else if (node::Buffer::HasInstance(args[3])) {
    arg4 = node::Buffer::Data(Nan::To<v8::Object>(args[3]).ToLocalChecked());
    // printf("data: %s - %i\n", arg4, strlen(arg4));
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlTextWriterWriteFormatDTDInternalEntity" "', argument " "4"" of type '" "char const *""'");
    }
    
    arg4 = reinterpret_cast< char * >(buf4);
  }result = (int)xmlTextWriterWriteFormatDTDInternalEntity(arg1,arg2,(unsigned char const *)arg3,(char const *)arg4,arg5);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  // free(arg4);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteDTDInternalEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  int arg2 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteDTDInternalEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteDTDInternalEntity" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlTextWriterWriteDTDInternalEntity" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteDTDInternalEntity" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlTextWriterWriteDTDInternalEntity" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (int)xmlTextWriterWriteDTDInternalEntity(arg1,arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteDTDExternalEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  int arg2 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  xmlChar *arg6 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  size_t size6 = 0 ;
  int alloc6 = 0 ;
  int result;
  
  if (args.Length() < 6 || args.Length() > 6) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteDTDExternalEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteDTDExternalEntity" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlTextWriterWriteDTDExternalEntity" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteDTDExternalEntity" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlTextWriterWriteDTDExternalEntity" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlTextWriterWriteDTDExternalEntity" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }if (args[5]->IsNull()) {
    arg6 = NULL;
  } else {
    res6 = SWIG_AsCharPtrAndSize(args[5], &buf6, &size6, &alloc6);
    
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlTextWriterWriteDTDExternalEntity" "', argument " "6"" of type '" "xmlChar const *""'");
    }
    
    arg6 = reinterpret_cast< xmlChar * >(buf6);
  }result = (int)xmlTextWriterWriteDTDExternalEntity(arg1,arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,(unsigned char const *)arg5,(unsigned char const *)arg6);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteDTDExternalEntityContents(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteDTDExternalEntityContents.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteDTDExternalEntityContents" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteDTDExternalEntityContents" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteDTDExternalEntityContents" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlTextWriterWriteDTDExternalEntityContents" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (int)xmlTextWriterWriteDTDExternalEntityContents(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteDTDEntity(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  int arg2 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  xmlChar *arg5 = (xmlChar *) 0 ;
  xmlChar *arg6 = (xmlChar *) 0 ;
  xmlChar *arg7 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  size_t size5 = 0 ;
  int alloc5 = 0 ;
  int res6 ;
  char *buf6 = 0 ;
  size_t size6 = 0 ;
  int alloc6 = 0 ;
  int res7 ;
  char *buf7 = 0 ;
  size_t size7 = 0 ;
  int alloc7 = 0 ;
  int result;
  
  if (args.Length() < 7 || args.Length() > 7) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteDTDEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteDTDEntity" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlTextWriterWriteDTDEntity" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteDTDEntity" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlTextWriterWriteDTDEntity" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }if (args[4]->IsNull()) {
    arg5 = NULL;
  } else {
    res5 = SWIG_AsCharPtrAndSize(args[4], &buf5, &size5, &alloc5);
    
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "xmlTextWriterWriteDTDEntity" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }if (args[5]->IsNull()) {
    arg6 = NULL;
  } else {
    res6 = SWIG_AsCharPtrAndSize(args[5], &buf6, &size6, &alloc6);
    
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "xmlTextWriterWriteDTDEntity" "', argument " "6"" of type '" "xmlChar const *""'");
    }
    
    arg6 = reinterpret_cast< xmlChar * >(buf6);
  }if (args[6]->IsNull()) {
    arg7 = NULL;
  } else {
    res7 = SWIG_AsCharPtrAndSize(args[6], &buf7, &size7, &alloc7);
    
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "xmlTextWriterWriteDTDEntity" "', argument " "7"" of type '" "xmlChar const *""'");
    }
    
    arg7 = reinterpret_cast< xmlChar * >(buf7);
  }result = (int)xmlTextWriterWriteDTDEntity(arg1,arg2,(unsigned char const *)arg3,(unsigned char const *)arg4,(unsigned char const *)arg5,(unsigned char const *)arg6,(unsigned char const *)arg7);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterWriteDTDNotation(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  xmlChar *arg4 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  size_t size3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  size_t size4 = 0 ;
  int alloc4 = 0 ;
  int result;
  
  if (args.Length() < 4 || args.Length() > 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterWriteDTDNotation.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterWriteDTDNotation" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterWriteDTDNotation" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }if (args[2]->IsNull()) {
    arg3 = NULL;
  } else {
    res3 = SWIG_AsCharPtrAndSize(args[2], &buf3, &size3, &alloc3);
    
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlTextWriterWriteDTDNotation" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }if (args[3]->IsNull()) {
    arg4 = NULL;
  } else {
    res4 = SWIG_AsCharPtrAndSize(args[3], &buf4, &size4, &alloc4);
    
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "xmlTextWriterWriteDTDNotation" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }result = (int)xmlTextWriterWriteDTDNotation(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,(unsigned char const *)arg4);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterSetIndent(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterSetIndent.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterSetIndent" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlTextWriterSetIndent" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);result = (int)xmlTextWriterSetIndent(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterSetIndentString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar *arg2 = (xmlChar *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterSetIndentString.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterSetIndentString" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);if (args[1]->IsNull()) {
    arg2 = NULL;
  } else {
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, &size2, &alloc2);
    
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlTextWriterSetIndentString" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }result = (int)xmlTextWriterSetIndentString(arg1,(unsigned char const *)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterSetQuoteChar(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  xmlChar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  int result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterSetQuoteChar.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterSetQuoteChar" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);ecode2 = SWIG_AsVal_unsigned_SS_char(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlTextWriterSetQuoteChar" "', argument " "2"" of type '" "xmlChar""'");
  } 
  arg2 = static_cast< xmlChar >(val2);result = (int)xmlTextWriterSetQuoteChar(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterFlush(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterFlush.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterFlush" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);result = (int)xmlTextWriterFlush(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlTextWriterClose(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlTextWriterPtr arg1 = (xmlTextWriterPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  if (args.Length() < 1 || args.Length() > 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlTextWriterClose.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlTextWriter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTextWriterClose" "', argument " "1"" of type '" "xmlTextWriterPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlTextWriterPtr >(argp1);result = (int)xmlTextWriterClose(arg1);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPtrNewContext(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDocPtr arg1 = (xmlDocPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  int res3 ;
  void *arg30 ;
  xmlXPathContextPtr result;
  
  if (args.Length() < 3 || args.Length() > 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPtrNewContext.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlXPtrNewContext', argument 1 of type 'xmlDocPtr'"); 
  }
  arg1 = (xmlDocPtr) arg10;res2 = SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res2)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[1], &arg20, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method 'xmlXPtrNewContext', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);res3 = SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlNode, 0 | 0 );
  
  if (!SWIG_IsOK(res3)) {
    if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDoc, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlAttr, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlDtd, 0 | 0))) {
      
    } else if (SWIG_IsOK(SWIG_ConvertPtr(args[2], &arg30, SWIGTYPE_p__xmlElement, 0 | 0))) {
      
    } else {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method 'xmlXPtrNewContext', argument 3 of type 'xmlNodePtr'"); 
    }
  }
  
  arg3 = ((xmlNodePtr) arg30);result = (xmlXPathContextPtr)xmlXPtrNewContext(arg1,arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPtrEval(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlChar *arg1 = (xmlChar *) 0 ;
  xmlXPathContextPtr arg2 = (xmlXPathContextPtr) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlXPathObjectPtr result;
  
  if (args.Length() < 2 || args.Length() > 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPtrEval.");
  
  if (args[0]->IsNull()) {
    arg1 = NULL;
  } else {
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPtrEval" "', argument " "1"" of type '" "xmlChar const *""'");
    }
    
    arg1 = reinterpret_cast< xmlChar * >(buf1);
  }res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlXPathContext, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPtrEval" "', argument " "2"" of type '" "xmlXPathContextPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathContextPtr >(argp2);result = (xmlXPathObjectPtr)xmlXPtrEval((unsigned char const *)arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__htmlElemDesc = {"_p__htmlElemDesc", "_htmlElemDesc *|htmlElemDesc *|p__htmlElemDesc", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__htmlEntityDesc = {"_p__htmlEntityDesc", "_htmlEntityDesc *|htmlEntityDesc *|p__htmlEntityDesc", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xlinkHandler = {"_p__xlinkHandler", "_xlinkHandler *|xlinkHandler *|xlinkHandlerPtr|p__xlinkHandler", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlAttr = {"_p__xmlAttr", "p__xmlAttr|xmlAttr *|xmlAttrPtr|_xmlAttr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlAttrHashBucket = {"_p__xmlAttrHashBucket", "xmlAttrHashBucket *|_xmlAttrHashBucket *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlAttribute = {"_p__xmlAttribute", "p__xmlAttribute|xmlAttribute *|xmlAttributePtr|_xmlAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlAutomata = {"_p__xmlAutomata", "xmlAutomata *|xmlAutomataPtr|_xmlAutomata *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlAutomataState = {"_p__xmlAutomataState", "xmlAutomataState *|xmlAutomataStatePtr|_xmlAutomataState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlBuf = {"_p__xmlBuf", "xmlBuf *|xmlBufPtr|_xmlBuf *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlBuffer = {"_p__xmlBuffer", "p__xmlBuffer|xmlBuffer *|xmlBufferPtr|_xmlBuffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlCatalog = {"_p__xmlCatalog", "xmlCatalog *|xmlCatalogPtr|_xmlCatalog *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlChLRange = {"_p__xmlChLRange", "_xmlChLRange *|xmlChLRange *|p__xmlChLRange", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlChRangeGroup = {"_p__xmlChRangeGroup", "p__xmlChRangeGroup|xmlChRangeGroup *|_xmlChRangeGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlChSRange = {"_p__xmlChSRange", "_xmlChSRange *|xmlChSRange *|p__xmlChSRange", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlCharEncodingHandler = {"_p__xmlCharEncodingHandler", "p__xmlCharEncodingHandler|xmlCharEncodingHandler *|xmlCharEncodingHandlerPtr|_xmlCharEncodingHandler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlDOMWrapCtxt = {"_p__xmlDOMWrapCtxt", "_xmlDOMWrapCtxt *|xmlDOMWrapCtxt *|xmlDOMWrapCtxtPtr|p__xmlDOMWrapCtxt", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlDict = {"_p__xmlDict", "xmlDict *|xmlDictPtr|_xmlDict *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlDoc = {"_p__xmlDoc", "htmlDocPtr|p__xmlDoc|xmlDoc *|xmlDocPtr|_xmlDoc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlDtd = {"_p__xmlDtd", "_xmlDtd *|xmlDtd *|xmlDtdPtr|p__xmlDtd", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlElement = {"_p__xmlElement", "p__xmlElement|xmlElement *|xmlElementPtr|_xmlElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlElementContent = {"_p__xmlElementContent", "p__xmlElementContent|xmlElementContent *|xmlElementContentPtr|_xmlElementContent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlEntity = {"_p__xmlEntity", "_xmlEntity *|xmlEntity *|xmlEntityPtr|p__xmlEntity", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlEnumeration = {"_p__xmlEnumeration", "p__xmlEnumeration|xmlEnumeration *|xmlEnumerationPtr|_xmlEnumeration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlError = {"_p__xmlError", "p__xmlError|xmlError *|xmlErrorPtr|_xmlError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlGlobalState = {"_p__xmlGlobalState", "xmlGlobalState *|xmlGlobalStatePtr|_xmlGlobalState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlHashTable = {"_p__xmlHashTable", "xmlAttributeTable *|xmlAttributeTablePtr|xmlElementTable *|xmlElementTablePtr|xmlEntitiesTable *|xmlEntitiesTablePtr|xmlHashTable *|xmlHashTablePtr|xmlIDTable *|xmlIDTablePtr|xmlNotationTable *|xmlNotationTablePtr|xmlRefTable *|xmlRefTablePtr|_xmlHashTable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlID = {"_p__xmlID", "p__xmlID|xmlID *|xmlIDPtr|_xmlID *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlLink = {"_p__xmlLink", "xmlLink *|xmlLinkPtr|_xmlLink *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlList = {"_p__xmlList", "xmlList *|xmlListPtr|_xmlList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlModule = {"_p__xmlModule", "xmlModule *|xmlModulePtr|_xmlModule *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlMutex = {"_p__xmlMutex", "xmlMutex *|xmlMutexPtr|_xmlMutex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlNode = {"_p__xmlNode", "htmlNodePtr|p__xmlNode|xmlNode *|xmlNodePtr|_xmlNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlNodeSet = {"_p__xmlNodeSet", "p__xmlNodeSet|xmlNodeSet *|xmlNodeSetPtr|_xmlNodeSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlNotation = {"_p__xmlNotation", "p__xmlNotation|xmlNotation *|xmlNotationPtr|_xmlNotation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlNs = {"_p__xmlNs", "_xmlNs *|xmlNs *|xmlNsPtr|p__xmlNs", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlOutputBuffer = {"_p__xmlOutputBuffer", "p__xmlOutputBuffer|xmlOutputBuffer *|xmlOutputBufferPtr|_xmlOutputBuffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlParserCtxt = {"_p__xmlParserCtxt", "_xmlParserCtxt *|htmlParserCtxt *|htmlParserCtxtPtr|xmlParserCtxt *|xmlParserCtxtPtr|p__xmlParserCtxt", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlParserInput = {"_p__xmlParserInput", "htmlParserInput *|p__xmlParserInput|xmlParserInput *|xmlParserInputPtr|_xmlParserInput *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlParserInputBuffer = {"_p__xmlParserInputBuffer", "p__xmlParserInputBuffer|xmlParserInputBuffer *|xmlParserInputBufferPtr|_xmlParserInputBuffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlParserNodeInfo = {"_p__xmlParserNodeInfo", "htmlParserNodeInfo *|p__xmlParserNodeInfo|xmlParserNodeInfo *|xmlParserNodeInfoPtr|_xmlParserNodeInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlParserNodeInfoSeq = {"_p__xmlParserNodeInfoSeq", "p__xmlParserNodeInfoSeq|xmlParserNodeInfoSeq *|xmlParserNodeInfoSeqPtr|_xmlParserNodeInfoSeq *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlParserNsData = {"_p__xmlParserNsData", "xmlParserNsData *|_xmlParserNsData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlPattern = {"_p__xmlPattern", "xmlPattern *|xmlPatternPtr|_xmlPattern *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlRMutex = {"_p__xmlRMutex", "xmlRMutex *|xmlRMutexPtr|_xmlRMutex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlRef = {"_p__xmlRef", "p__xmlRef|xmlRef *|xmlRefPtr|_xmlRef *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlRegExecCtxt = {"_p__xmlRegExecCtxt", "xmlRegExecCtxt *|xmlRegExecCtxtPtr|_xmlRegExecCtxt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlRegexp = {"_p__xmlRegexp", "xmlRegexp *|xmlRegexpPtr|_xmlRegexp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlRelaxNG = {"_p__xmlRelaxNG", "xmlRelaxNG *|xmlRelaxNGPtr|_xmlRelaxNG *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlRelaxNGParserCtxt = {"_p__xmlRelaxNGParserCtxt", "xmlRelaxNGParserCtxt *|xmlRelaxNGParserCtxtPtr|_xmlRelaxNGParserCtxt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlRelaxNGValidCtxt = {"_p__xmlRelaxNGValidCtxt", "xmlRelaxNGValidCtxt *|xmlRelaxNGValidCtxtPtr|_xmlRelaxNGValidCtxt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSAXHandler = {"_p__xmlSAXHandler", "htmlSAXHandler *|htmlSAXHandlerPtr|p__xmlSAXHandler|xmlSAXHandler *|xmlSAXHandlerPtr|_xmlSAXHandler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSAXHandlerV1 = {"_p__xmlSAXHandlerV1", "p__xmlSAXHandlerV1|xmlSAXHandlerV1 *|_xmlSAXHandlerV1 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSAXLocator = {"_p__xmlSAXLocator", "p__xmlSAXLocator|xmlSAXLocator *|xmlSAXLocatorPtr|_xmlSAXLocator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSaveCtxt = {"_p__xmlSaveCtxt", "xmlSaveCtxt *|xmlSaveCtxtPtr|_xmlSaveCtxt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSchema = {"_p__xmlSchema", "_xmlSchema *|xmlSchema *|xmlSchemaPtr|p__xmlSchema", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSchemaAnnot = {"_p__xmlSchemaAnnot", "_xmlSchemaAnnot *|xmlSchemaAnnot *|xmlSchemaAnnotPtr|p__xmlSchemaAnnot", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSchemaAttribute = {"_p__xmlSchemaAttribute", "p__xmlSchemaAttribute|xmlSchemaAttribute *|xmlSchemaAttributePtr|_xmlSchemaAttribute *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSchemaAttributeGroup = {"_p__xmlSchemaAttributeGroup", "p__xmlSchemaAttributeGroup|xmlSchemaAttributeGroup *|xmlSchemaAttributeGroupPtr|_xmlSchemaAttributeGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSchemaAttributeLink = {"_p__xmlSchemaAttributeLink", "p__xmlSchemaAttributeLink|xmlSchemaAttributeLink *|_xmlSchemaAttributeLink *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSchemaElement = {"_p__xmlSchemaElement", "p__xmlSchemaElement|xmlSchemaElement *|_xmlSchemaElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSchemaFacet = {"_p__xmlSchemaFacet", "_xmlSchemaFacet *|xmlSchemaFacet *|xmlSchemaFacetPtr|p__xmlSchemaFacet", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSchemaFacetLink = {"_p__xmlSchemaFacetLink", "p__xmlSchemaFacetLink|xmlSchemaFacetLink *|xmlSchemaFacetLinkPtr|_xmlSchemaFacetLink *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSchemaNotation = {"_p__xmlSchemaNotation", "_xmlSchemaNotation *|xmlSchemaNotation *|p__xmlSchemaNotation", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSchemaParserCtxt = {"_p__xmlSchemaParserCtxt", "xmlSchemaParserCtxt *|xmlSchemaParserCtxtPtr|_xmlSchemaParserCtxt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSchemaSAXPlug = {"_p__xmlSchemaSAXPlug", "xmlSchemaSAXPlugPtr|xmlSchemaSAXPlugStruct *|_xmlSchemaSAXPlug *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSchemaType = {"_p__xmlSchemaType", "_xmlSchemaType *|xmlSchemaType *|xmlSchemaTypePtr|p__xmlSchemaType", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSchemaTypeLink = {"_p__xmlSchemaTypeLink", "p__xmlSchemaTypeLink|xmlSchemaTypeLink *|xmlSchemaTypeLinkPtr|_xmlSchemaTypeLink *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSchemaVal = {"_p__xmlSchemaVal", "xmlSchemaVal *|xmlSchemaValPtr|_xmlSchemaVal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSchemaValidCtxt = {"_p__xmlSchemaValidCtxt", "xmlSchemaValidCtxt *|xmlSchemaValidCtxtPtr|_xmlSchemaValidCtxt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSchemaWildcard = {"_p__xmlSchemaWildcard", "p__xmlSchemaWildcard|xmlSchemaWildcard *|xmlSchemaWildcardPtr|_xmlSchemaWildcard *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlSchemaWildcardNs = {"_p__xmlSchemaWildcardNs", "p__xmlSchemaWildcardNs|xmlSchemaWildcardNs *|xmlSchemaWildcardNsPtr|_xmlSchemaWildcardNs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlStartTag = {"_p__xmlStartTag", "xmlStartTag *|_xmlStartTag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlStreamCtxt = {"_p__xmlStreamCtxt", "xmlStreamCtxt *|xmlStreamCtxtPtr|_xmlStreamCtxt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlTextReader = {"_p__xmlTextReader", "xmlTextReader *|xmlTextReaderPtr|_xmlTextReader *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlTextWriter = {"_p__xmlTextWriter", "xmlTextWriter *|xmlTextWriterPtr|_xmlTextWriter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlURI = {"_p__xmlURI", "p__xmlURI|xmlURI *|xmlURIPtr|_xmlURI *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlValidCtxt = {"_p__xmlValidCtxt", "p__xmlValidCtxt|xmlValidCtxt *|xmlValidCtxtPtr|_xmlValidCtxt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlValidState = {"_p__xmlValidState", "xmlValidState *|_xmlValidState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlXIncludeCtxt = {"_p__xmlXIncludeCtxt", "xmlXIncludeCtxt *|xmlXIncludeCtxtPtr|_xmlXIncludeCtxt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlXPathAxis = {"_p__xmlXPathAxis", "p__xmlXPathAxis|xmlXPathAxis *|xmlXPathAxisPtr|_xmlXPathAxis *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlXPathCompExpr = {"_p__xmlXPathCompExpr", "xmlXPathCompExpr *|xmlXPathCompExprPtr|_xmlXPathCompExpr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlXPathContext = {"_p__xmlXPathContext", "p__xmlXPathContext|xmlXPathContext *|xmlXPathContextPtr|_xmlXPathContext *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlXPathFunct = {"_p__xmlXPathFunct", "p__xmlXPathFunct|xmlXPathFunct *|_xmlXPathFunct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlXPathObject = {"_p__xmlXPathObject", "p__xmlXPathObject|xmlXPathObject *|xmlXPathObjectPtr|_xmlXPathObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlXPathParserContext = {"_p__xmlXPathParserContext", "p__xmlXPathParserContext|xmlXPathParserContext *|xmlXPathParserContextPtr|_xmlXPathParserContext *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlXPathType = {"_p__xmlXPathType", "p__xmlXPathType|xmlXPathType *|xmlXPathTypePtr|_xmlXPathType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlXPathVariable = {"_p__xmlXPathVariable", "p__xmlXPathVariable|xmlXPathVariable *|_xmlXPathVariable *", 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_f_p__xmlLink__void = {"_p_f_p__xmlLink__void", "xmlListDeallocator|void (*)(_xmlLink *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p__xmlNode__void = {"_p_f_p__xmlNode__void", "xmlDeregisterNodeFunc|xmlRegisterNodeFunc|void (*)(_xmlNode *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p__xmlRegExecCtxt_p_q_const__unsigned_char_p_void_p_void__void = {"_p_f_p__xmlRegExecCtxt_p_q_const__unsigned_char_p_void_p_void__void", "xmlRegExecCallbacks|void (*)(_xmlRegExecCtxt *,unsigned char const *,void *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p__xmlXPathObject_int__int = {"_p_f_p__xmlXPathObject_int__int", "xmlXPathConvertFunc|int (*)(_xmlXPathObject *,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p__xmlXPathParserContext_int__void = {"_p_f_p__xmlXPathParserContext_int__void", "xmlXPathEvalFunc|xmlXPathFunction|void (*)(_xmlXPathParserContext *,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__char__int = {"_p_f_p_q_const__char__int", "xmlInputMatchCallback|xmlOutputMatchCallback|int (*)(char const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__char__p_char = {"_p_f_p_q_const__char__p_char", "xmlStrdupFunc|char *(*)(char const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__char__p_void = {"_p_f_p_q_const__char__p_void", "xmlInputOpenCallback|xmlOutputOpenCallback|void *(*)(char const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_p_q_const__char_xmlParserCtxtPtr__p__xmlParserInput = {"_p_f_p_q_const__char_p_q_const__char_xmlParserCtxtPtr__p__xmlParserInput", "xmlExternalEntityLoader|_xmlParserInput *(*)(char const *,char const *,xmlParserCtxtPtr)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer = {"_p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer", "xmlOutputBufferCreateFilenameFunc|_xmlOutputBuffer *(*)(char const *,xmlCharEncodingHandlerPtr,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer = {"_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer", "xmlParserInputBufferCreateFilenameFunc|_xmlParserInputBuffer *(*)(char const *,xmlCharEncoding)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__void_p_q_const__void__int = {"_p_f_p_q_const__void_p_q_const__void__int", "xmlListDataCompare|int (*)(void const *,void const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__void_p_void__int = {"_p_f_p_q_const__void_p_void__int", "xmlListWalker|int (*)(void const *,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_unsigned_char__void = {"_p_f_p_unsigned_char__void", "xmlParserInputDeallocate|void (*)(unsigned char *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_unsigned_char_p_int_p_q_const__unsigned_char_p_int__int = {"_p_f_p_unsigned_char_p_int_p_q_const__unsigned_char_p_int__int", "xmlCharEncodingInputFunc|xmlCharEncodingOutputFunc|int (*)(unsigned char *,int *,unsigned char const *,int *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void__int = {"_p_f_p_void__int", "hasExternalSubsetSAXFunc|hasInternalSubsetSAXFunc|isStandaloneSAXFunc|xmlInputCloseCallback|xmlOutputCloseCallback|int (*)(void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void__p_unsigned_char = {"_p_f_p_void__p_unsigned_char", "xmlChar *(*)(void *)|unsigned char *(*)(void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void__void = {"_p_f_p_void__void", "endDocumentSAXFunc|startDocumentSAXFunc|xmlFreeFunc|void (*)(void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p__xmlNode__void = {"_p_f_p_void_p__xmlNode__void", "xlinkNodeDetectFunc|void (*)(void *,_xmlNode *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void = {"_p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void", "xlinkExtendedLinkSetFunk|void (*)(void *,_xmlNode *,int,unsigned char *const *,unsigned char *const *,int,unsigned char *const *,unsigned char const **)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_p_enum_xlinkShow_p_enum_xlinkActuate_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void = {"_p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_p_enum_xlinkShow_p_enum_xlinkActuate_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void", "xlinkExtendedLinkFunk|void (*)(void *,_xmlNode *,int,unsigned char *const *,unsigned char *const *,int,unsigned char *const *,unsigned char *const *,enum xlinkShow *,enum xlinkActuate *,int,unsigned char *const *,unsigned char const **)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p__xmlNode_q_const__p_unsigned_char_q_const__p_unsigned_char_q_const__p_unsigned_char__void = {"_p_f_p_void_p__xmlNode_q_const__p_unsigned_char_q_const__p_unsigned_char_q_const__p_unsigned_char__void", "xlinkSimpleLinkFunk|void (*)(void *,_xmlNode *,unsigned char *const,unsigned char *const,unsigned char *const)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p__xmlSAXLocator__void = {"_p_f_p_void_p__xmlSAXLocator__void", "setDocumentLocatorSAXFunc|void (*)(void *,_xmlSAXLocator *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_char_int__int = {"_p_f_p_void_p_char_int__int", "xmlInputReadCallback|int (*)(void *,char *,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_p_q_const__char_p_unsigned_long__int = {"_p_f_p_void_p_p_q_const__char_p_unsigned_long__int", "xmlSchemaValidityLocatorFunc|int (*)(void *,char const **,unsigned long *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const___xmlError__void = {"_p_f_p_void_p_q_const___xmlError__void", "xmlStructuredErrorFunc|void (*)(void *,_xmlError const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__char_enum_xmlParserSeverities_p_void__void = {"_p_f_p_void_p_q_const__char_enum_xmlParserSeverities_p_void__void", "xmlTextReaderErrorFunc|void (*)(void *,char const *,enum xmlParserSeverities,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__char_int__int = {"_p_f_p_void_p_q_const__char_int__int", "xmlOutputWriteCallback|int (*)(void *,char const *,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__char_v_______void = {"_p_f_p_void_p_q_const__char_v_______void", "errorSAXFunc|fatalErrorSAXFunc|warningSAXFunc|xmlGenericErrorFunc|xmlRelaxNGValidityErrorFunc|xmlRelaxNGValidityWarningFunc|xmlSchemaValidityErrorFunc|xmlSchemaValidityWarningFunc|xmlValidityErrorFunc|xmlValidityWarningFunc|void (*)(void *,char const *,...)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__unsigned_char__p_void = {"_p_f_p_void_p_q_const__unsigned_char__p_void", "xmlHashCopier|void *(*)(void *,unsigned char const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__unsigned_char__void = {"_p_f_p_void_p_q_const__unsigned_char__void", "commentSAXFunc|endElementSAXFunc|referenceSAXFunc|xmlHashDeallocator|void (*)(void *,unsigned char const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__unsigned_char_int__void = {"_p_f_p_void_p_q_const__unsigned_char_int__void", "cdataBlockSAXFunc|charactersSAXFunc|ignorableWhitespaceSAXFunc|void (*)(void *,unsigned char const *,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__unsigned_char_int_p__xmlElementContent__void = {"_p_f_p_void_p_q_const__unsigned_char_int_p__xmlElementContent__void", "elementDeclSAXFunc|void (*)(void *,unsigned char const *,int,_xmlElementContent *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__unsigned_char_int_p_q_const__unsigned_char_p_q_const__unsigned_char_p_unsigned_char__void = {"_p_f_p_void_p_q_const__unsigned_char_int_p_q_const__unsigned_char_p_q_const__unsigned_char_p_unsigned_char__void", "entityDeclSAXFunc|void (*)(void *,unsigned char const *,int,unsigned char const *,unsigned char const *,unsigned char *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__unsigned_char_p_p_q_const__unsigned_char__void = {"_p_f_p_void_p_q_const__unsigned_char_p_p_q_const__unsigned_char__void", "startElementSAXFunc|void (*)(void *,unsigned char const *,unsigned char const **)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__p_f_p__xmlXPathParserContext_int__void = {"_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__p_f_p__xmlXPathParserContext_int__void", "xmlXPathFuncLookupFunc|void (*(*)(void *,unsigned char const *,unsigned char const *))(_xmlXPathParserContext *,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__void = {"_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__void", "processingInstructionSAXFunc|void (*)(void *,unsigned char const *,unsigned char const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_int_int_p_q_const__unsigned_char_p__xmlEnumeration__void = {"_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_int_int_p_q_const__unsigned_char_p__xmlEnumeration__void", "attributeDeclSAXFunc|void (*)(void *,unsigned char const *,unsigned char const *,int,int,unsigned char const *,_xmlEnumeration *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void = {"_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void", "endElementNsSAX2Func|externalSubsetSAXFunc|internalSubsetSAXFunc|notationDeclSAXFunc|void (*)(void *,unsigned char const *,unsigned char const *,unsigned char const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_int_p_p_q_const__unsigned_char_int_int_p_p_q_const__unsigned_char__void = {"_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_int_p_p_q_const__unsigned_char_int_int_p_p_q_const__unsigned_char__void", "startElementNsSAX2Func|void (*)(void *,unsigned char const *,unsigned char const *,unsigned char const *,int,unsigned char const **,int,int,unsigned char const **)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void = {"_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void", "unparsedEntityDeclSAXFunc|void (*)(void *,unsigned char const *,unsigned char const *,unsigned char const *,unsigned char const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__xmlChar__p__xmlEntity = {"_p_f_p_void_p_q_const__xmlChar__p__xmlEntity", "getEntitySAXFunc|getParameterEntitySAXFunc|_xmlEntity *(*)(void *,xmlChar const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlParserInput = {"_p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlParserInput", "resolveEntitySAXFunc|_xmlParserInput *(*)(void *,xmlChar const *,xmlChar const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlXPathObject = {"_p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlXPathObject", "xmlXPathVariableLookupFunc|_xmlXPathObject *(*)(void *,xmlChar const *,xmlChar const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_void_p_q_const__unsigned_char__void = {"_p_f_p_void_p_void_p_q_const__unsigned_char__void", "xmlHashScanner|void (*)(void *,void *,unsigned char const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void = {"_p_f_p_void_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void", "xmlHashScannerFull|void (*)(void *,void *,unsigned char const *,unsigned char const *,unsigned char const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_void_size_t__p_void = {"_p_f_p_void_size_t__p_void", "xmlReallocFunc|void *(*)(void *,size_t)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_size_t__p_void = {"_p_f_size_t__p_void", "xmlMallocFunc|void *(*)(size_t)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_xmlDOMWrapCtxtPtr_xmlNodePtr_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlNs = {"_p_f_xmlDOMWrapCtxtPtr_xmlNodePtr_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlNs", "xmlDOMWrapAcquireNsFunction|_xmlNs *(*)(xmlDOMWrapCtxtPtr,xmlNodePtr,xmlChar const *,xmlChar const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_xmlXPathParserContextPtr_xmlXPathObjectPtr__p__xmlXPathObject = {"_p_f_xmlXPathParserContextPtr_xmlXPathObjectPtr__p__xmlXPathObject", "xmlXPathAxisFunc|_xmlXPathObject *(*)(xmlXPathParserContextPtr,xmlXPathObjectPtr)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_htmlParserOption = {"_p_htmlParserOption", "htmlParserOption *|enum htmlParserOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_htmlStatus = {"_p_htmlStatus", "htmlStatus *|enum htmlStatus *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iconv_t = {"_p_iconv_t", "iconv_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__xmlCharEncodingHandler = {"_p_p__xmlCharEncodingHandler", "xmlCharEncodingHandlerPtr *|_xmlCharEncodingHandler **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__xmlDoc = {"_p_p__xmlDoc", "htmlDocPtr *|xmlDocPtr *|_xmlDoc **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__xmlElementContent = {"_p_p__xmlElementContent", "xmlElementContentPtr *|_xmlElementContent **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__xmlEntity = {"_p_p__xmlEntity", "xmlEntityPtr *|_xmlEntity **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__xmlEnumeration = {"_p_p__xmlEnumeration", "xmlEnumerationPtr *|_xmlEnumeration **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__xmlNode = {"_p_p__xmlNode", "htmlNodePtr *|xmlNodePtr *|_xmlNode **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__xmlNs = {"_p_p__xmlNs", "xmlNsPtr *|_xmlNs **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__xmlParserCtxt = {"_p_p__xmlParserCtxt", "htmlParserCtxtPtr *|_xmlParserCtxt **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__xmlParserInput = {"_p_p__xmlParserInput", "htmlParserInputPtr *|xmlParserInputPtr *|_xmlParserInput **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__xmlPattern = {"_p_p__xmlPattern", "xmlPatternPtr *|_xmlPattern **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__xmlSAXHandler = {"_p_p__xmlSAXHandler", "htmlSAXHandlerPtr *|xmlSAXHandlerPtr *|_xmlSAXHandler **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__xmlSchemaAttributeLink = {"_p_p__xmlSchemaAttributeLink", "xmlSchemaAttributeLinkPtr *|_xmlSchemaAttributeLink **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__xmlSchemaVal = {"_p_p__xmlSchemaVal", "xmlSchemaValPtr *|_xmlSchemaVal **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__xmlURI = {"_p_p__xmlURI", "xmlURIPtr *|_xmlURI **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__xmlXPathObject = {"_p_p__xmlXPathObject", "xmlXPathObjectPtr *|_xmlXPathObject **", 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_f_p__xmlNode__void = {"_p_p_f_p__xmlNode__void", "xmlDeregisterNodeFunc *|xmlRegisterNodeFunc *|void (**)(_xmlNode *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_q_const__char__p_char = {"_p_p_f_p_q_const__char__p_char", "xmlStrdupFunc *|char *(**)(char const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer = {"_p_p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer", "xmlOutputBufferCreateFilenameFunc *|_xmlOutputBuffer *(**)(char const *,xmlCharEncodingHandlerPtr,int)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer = {"_p_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer", "xmlParserInputBufferCreateFilenameFunc *|_xmlParserInputBuffer *(**)(char const *,xmlCharEncoding)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_void__void = {"_p_p_f_p_void__void", "xmlFreeFunc *|void (**)(void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_void_p_q_const___xmlError__void = {"_p_p_f_p_void_p_q_const___xmlError__void", "xmlStructuredErrorFunc *|void (**)(void *,_xmlError const *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_void_p_q_const__char_enum_xmlParserSeverities_p_void__void = {"_p_p_f_p_void_p_q_const__char_enum_xmlParserSeverities_p_void__void", "xmlTextReaderErrorFunc *|void (**)(void *,char const *,enum xmlParserSeverities,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_void_p_q_const__char_v_______void = {"_p_p_f_p_void_p_q_const__char_v_______void", "xmlGenericErrorFunc *|xmlRelaxNGValidityErrorFunc *|xmlRelaxNGValidityWarningFunc *|xmlSchemaValidityErrorFunc *|xmlSchemaValidityWarningFunc *|void (**)(void *,char const *,...)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_p_void_size_t__p_void = {"_p_p_f_p_void_size_t__p_void", "xmlReallocFunc *|void *(**)(void *,size_t)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_f_size_t__p_void = {"_p_p_f_size_t__p_void", "xmlMallocFunc *|void *(**)(size_t)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_p__xmlNs = {"_p_p_p__xmlNs", "xmlNsPtr **|_xmlNs ***", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_unsigned_char = {"_p_p_unsigned_char", "xmlChar **|unsigned char **", 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_unsigned_char = {"_p_unsigned_char", "xmlChar *|unsigned char *", 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_long = {"_p_unsigned_long", "unsigned long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xlinkActuate = {"_p_xlinkActuate", "xlinkActuate *|enum xlinkActuate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xlinkShow = {"_p_xlinkShow", "xlinkShow *|enum xlinkShow *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xlinkType = {"_p_xlinkType", "xlinkType *|enum xlinkType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlAttributeDefault = {"_p_xmlAttributeDefault", "xmlAttributeDefault *|enum xmlAttributeDefault *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlAttributeType = {"_p_xmlAttributeType", "xmlAttributeType *|enum xmlAttributeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlBufferAllocationScheme = {"_p_xmlBufferAllocationScheme", "xmlBufferAllocationScheme *|enum xmlBufferAllocationScheme *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlCatalogAllow = {"_p_xmlCatalogAllow", "xmlCatalogAllow *|enum xmlCatalogAllow *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlCatalogPrefer = {"_p_xmlCatalogPrefer", "xmlCatalogPrefer *|enum xmlCatalogPrefer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlCharEncError = {"_p_xmlCharEncError", "xmlCharEncError *|enum xmlCharEncError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlCharEncoding = {"_p_xmlCharEncoding", "xmlCharEncoding *|enum xmlCharEncoding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlDocProperties = {"_p_xmlDocProperties", "xmlDocProperties *|enum xmlDocProperties *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlElementContentOccur = {"_p_xmlElementContentOccur", "xmlElementContentOccur *|enum xmlElementContentOccur *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlElementContentType = {"_p_xmlElementContentType", "xmlElementContentType *|enum xmlElementContentType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlElementType = {"_p_xmlElementType", "xmlElementType *|xmlNsType *|enum xmlElementType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlElementTypeVal = {"_p_xmlElementTypeVal", "xmlElementTypeVal *|enum xmlElementTypeVal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlEntityType = {"_p_xmlEntityType", "xmlEntityType *|enum xmlEntityType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlErrorDomain = {"_p_xmlErrorDomain", "xmlErrorDomain *|enum xmlErrorDomain *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlErrorLevel = {"_p_xmlErrorLevel", "xmlErrorLevel *|enum xmlErrorLevel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlFeature = {"_p_xmlFeature", "xmlFeature *|enum xmlFeature *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlModuleOption = {"_p_xmlModuleOption", "xmlModuleOption *|enum xmlModuleOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlParserErrors = {"_p_xmlParserErrors", "xmlParserErrors *|enum xmlParserErrors *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlParserInputState = {"_p_xmlParserInputState", "xmlParserInputState *|enum xmlParserInputState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlParserMode = {"_p_xmlParserMode", "xmlParserMode *|enum xmlParserMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlParserOption = {"_p_xmlParserOption", "xmlParserOption *|enum xmlParserOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlParserProperties = {"_p_xmlParserProperties", "xmlParserProperties *|enum xmlParserProperties *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlParserSeverities = {"_p_xmlParserSeverities", "xmlParserSeverities *|enum xmlParserSeverities *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlPatternFlags = {"_p_xmlPatternFlags", "xmlPatternFlags *|enum xmlPatternFlags *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlReaderTypes = {"_p_xmlReaderTypes", "xmlReaderTypes *|enum xmlReaderTypes *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlRelaxNGParserFlag = {"_p_xmlRelaxNGParserFlag", "xmlRelaxNGParserFlag *|enum xmlRelaxNGParserFlag *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlRelaxNGValidErr = {"_p_xmlRelaxNGValidErr", "xmlRelaxNGValidErr *|enum xmlRelaxNGValidErr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlSaveOption = {"_p_xmlSaveOption", "xmlSaveOption *|enum xmlSaveOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlSchemaContentType = {"_p_xmlSchemaContentType", "xmlSchemaContentType *|enum xmlSchemaContentType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlSchemaTypeType = {"_p_xmlSchemaTypeType", "xmlSchemaTypeType *|enum xmlSchemaTypeType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlSchemaValType = {"_p_xmlSchemaValType", "xmlSchemaValType *|enum xmlSchemaValType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlSchemaValidError = {"_p_xmlSchemaValidError", "xmlSchemaValidError *|enum xmlSchemaValidError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlSchemaValidOption = {"_p_xmlSchemaValidOption", "xmlSchemaValidOption *|enum xmlSchemaValidOption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlSchemaWhitespaceValueType = {"_p_xmlSchemaWhitespaceValueType", "xmlSchemaWhitespaceValueType *|enum xmlSchemaWhitespaceValueType *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlTextReaderMode = {"_p_xmlTextReaderMode", "xmlTextReaderMode *|enum xmlTextReaderMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlXPathError = {"_p_xmlXPathError", "xmlXPathError *|enum xmlXPathError *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_xmlXPathObjectType = {"_p_xmlXPathObjectType", "xmlXPathObjectType *|enum xmlXPathObjectType *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_FILE,
  &_swigt__p__htmlElemDesc,
  &_swigt__p__htmlEntityDesc,
  &_swigt__p__xlinkHandler,
  &_swigt__p__xmlAttr,
  &_swigt__p__xmlAttrHashBucket,
  &_swigt__p__xmlAttribute,
  &_swigt__p__xmlAutomata,
  &_swigt__p__xmlAutomataState,
  &_swigt__p__xmlBuf,
  &_swigt__p__xmlBuffer,
  &_swigt__p__xmlCatalog,
  &_swigt__p__xmlChLRange,
  &_swigt__p__xmlChRangeGroup,
  &_swigt__p__xmlChSRange,
  &_swigt__p__xmlCharEncodingHandler,
  &_swigt__p__xmlDOMWrapCtxt,
  &_swigt__p__xmlDict,
  &_swigt__p__xmlDoc,
  &_swigt__p__xmlDtd,
  &_swigt__p__xmlElement,
  &_swigt__p__xmlElementContent,
  &_swigt__p__xmlEntity,
  &_swigt__p__xmlEnumeration,
  &_swigt__p__xmlError,
  &_swigt__p__xmlGlobalState,
  &_swigt__p__xmlHashTable,
  &_swigt__p__xmlID,
  &_swigt__p__xmlLink,
  &_swigt__p__xmlList,
  &_swigt__p__xmlModule,
  &_swigt__p__xmlMutex,
  &_swigt__p__xmlNode,
  &_swigt__p__xmlNodeSet,
  &_swigt__p__xmlNotation,
  &_swigt__p__xmlNs,
  &_swigt__p__xmlOutputBuffer,
  &_swigt__p__xmlParserCtxt,
  &_swigt__p__xmlParserInput,
  &_swigt__p__xmlParserInputBuffer,
  &_swigt__p__xmlParserNodeInfo,
  &_swigt__p__xmlParserNodeInfoSeq,
  &_swigt__p__xmlParserNsData,
  &_swigt__p__xmlPattern,
  &_swigt__p__xmlRMutex,
  &_swigt__p__xmlRef,
  &_swigt__p__xmlRegExecCtxt,
  &_swigt__p__xmlRegexp,
  &_swigt__p__xmlRelaxNG,
  &_swigt__p__xmlRelaxNGParserCtxt,
  &_swigt__p__xmlRelaxNGValidCtxt,
  &_swigt__p__xmlSAXHandler,
  &_swigt__p__xmlSAXHandlerV1,
  &_swigt__p__xmlSAXLocator,
  &_swigt__p__xmlSaveCtxt,
  &_swigt__p__xmlSchema,
  &_swigt__p__xmlSchemaAnnot,
  &_swigt__p__xmlSchemaAttribute,
  &_swigt__p__xmlSchemaAttributeGroup,
  &_swigt__p__xmlSchemaAttributeLink,
  &_swigt__p__xmlSchemaElement,
  &_swigt__p__xmlSchemaFacet,
  &_swigt__p__xmlSchemaFacetLink,
  &_swigt__p__xmlSchemaNotation,
  &_swigt__p__xmlSchemaParserCtxt,
  &_swigt__p__xmlSchemaSAXPlug,
  &_swigt__p__xmlSchemaType,
  &_swigt__p__xmlSchemaTypeLink,
  &_swigt__p__xmlSchemaVal,
  &_swigt__p__xmlSchemaValidCtxt,
  &_swigt__p__xmlSchemaWildcard,
  &_swigt__p__xmlSchemaWildcardNs,
  &_swigt__p__xmlStartTag,
  &_swigt__p__xmlStreamCtxt,
  &_swigt__p__xmlTextReader,
  &_swigt__p__xmlTextWriter,
  &_swigt__p__xmlURI,
  &_swigt__p__xmlValidCtxt,
  &_swigt__p__xmlValidState,
  &_swigt__p__xmlXIncludeCtxt,
  &_swigt__p__xmlXPathAxis,
  &_swigt__p__xmlXPathCompExpr,
  &_swigt__p__xmlXPathContext,
  &_swigt__p__xmlXPathFunct,
  &_swigt__p__xmlXPathObject,
  &_swigt__p__xmlXPathParserContext,
  &_swigt__p__xmlXPathType,
  &_swigt__p__xmlXPathVariable,
  &_swigt__p_char,
  &_swigt__p_f_p__xmlLink__void,
  &_swigt__p_f_p__xmlNode__void,
  &_swigt__p_f_p__xmlRegExecCtxt_p_q_const__unsigned_char_p_void_p_void__void,
  &_swigt__p_f_p__xmlXPathObject_int__int,
  &_swigt__p_f_p__xmlXPathParserContext_int__void,
  &_swigt__p_f_p_q_const__char__int,
  &_swigt__p_f_p_q_const__char__p_char,
  &_swigt__p_f_p_q_const__char__p_void,
  &_swigt__p_f_p_q_const__char_p_q_const__char_xmlParserCtxtPtr__p__xmlParserInput,
  &_swigt__p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer,
  &_swigt__p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer,
  &_swigt__p_f_p_q_const__void_p_q_const__void__int,
  &_swigt__p_f_p_q_const__void_p_void__int,
  &_swigt__p_f_p_unsigned_char__void,
  &_swigt__p_f_p_unsigned_char_p_int_p_q_const__unsigned_char_p_int__int,
  &_swigt__p_f_p_void__int,
  &_swigt__p_f_p_void__p_unsigned_char,
  &_swigt__p_f_p_void__void,
  &_swigt__p_f_p_void_p__xmlNode__void,
  &_swigt__p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void,
  &_swigt__p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_p_enum_xlinkShow_p_enum_xlinkActuate_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void,
  &_swigt__p_f_p_void_p__xmlNode_q_const__p_unsigned_char_q_const__p_unsigned_char_q_const__p_unsigned_char__void,
  &_swigt__p_f_p_void_p__xmlSAXLocator__void,
  &_swigt__p_f_p_void_p_char_int__int,
  &_swigt__p_f_p_void_p_p_q_const__char_p_unsigned_long__int,
  &_swigt__p_f_p_void_p_q_const___xmlError__void,
  &_swigt__p_f_p_void_p_q_const__char_enum_xmlParserSeverities_p_void__void,
  &_swigt__p_f_p_void_p_q_const__char_int__int,
  &_swigt__p_f_p_void_p_q_const__char_v_______void,
  &_swigt__p_f_p_void_p_q_const__unsigned_char__p_void,
  &_swigt__p_f_p_void_p_q_const__unsigned_char__void,
  &_swigt__p_f_p_void_p_q_const__unsigned_char_int__void,
  &_swigt__p_f_p_void_p_q_const__unsigned_char_int_p__xmlElementContent__void,
  &_swigt__p_f_p_void_p_q_const__unsigned_char_int_p_q_const__unsigned_char_p_q_const__unsigned_char_p_unsigned_char__void,
  &_swigt__p_f_p_void_p_q_const__unsigned_char_p_p_q_const__unsigned_char__void,
  &_swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__p_f_p__xmlXPathParserContext_int__void,
  &_swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__void,
  &_swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_int_int_p_q_const__unsigned_char_p__xmlEnumeration__void,
  &_swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void,
  &_swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_int_p_p_q_const__unsigned_char_int_int_p_p_q_const__unsigned_char__void,
  &_swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void,
  &_swigt__p_f_p_void_p_q_const__xmlChar__p__xmlEntity,
  &_swigt__p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlParserInput,
  &_swigt__p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlXPathObject,
  &_swigt__p_f_p_void_p_void_p_q_const__unsigned_char__void,
  &_swigt__p_f_p_void_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void,
  &_swigt__p_f_p_void_size_t__p_void,
  &_swigt__p_f_size_t__p_void,
  &_swigt__p_f_xmlDOMWrapCtxtPtr_xmlNodePtr_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlNs,
  &_swigt__p_f_xmlXPathParserContextPtr_xmlXPathObjectPtr__p__xmlXPathObject,
  &_swigt__p_htmlParserOption,
  &_swigt__p_htmlStatus,
  &_swigt__p_iconv_t,
  &_swigt__p_int,
  &_swigt__p_p__xmlCharEncodingHandler,
  &_swigt__p_p__xmlDoc,
  &_swigt__p_p__xmlElementContent,
  &_swigt__p_p__xmlEntity,
  &_swigt__p_p__xmlEnumeration,
  &_swigt__p_p__xmlNode,
  &_swigt__p_p__xmlNs,
  &_swigt__p_p__xmlParserCtxt,
  &_swigt__p_p__xmlParserInput,
  &_swigt__p_p__xmlPattern,
  &_swigt__p_p__xmlSAXHandler,
  &_swigt__p_p__xmlSchemaAttributeLink,
  &_swigt__p_p__xmlSchemaVal,
  &_swigt__p_p__xmlURI,
  &_swigt__p_p__xmlXPathObject,
  &_swigt__p_p_char,
  &_swigt__p_p_f_p__xmlNode__void,
  &_swigt__p_p_f_p_q_const__char__p_char,
  &_swigt__p_p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer,
  &_swigt__p_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer,
  &_swigt__p_p_f_p_void__void,
  &_swigt__p_p_f_p_void_p_q_const___xmlError__void,
  &_swigt__p_p_f_p_void_p_q_const__char_enum_xmlParserSeverities_p_void__void,
  &_swigt__p_p_f_p_void_p_q_const__char_v_______void,
  &_swigt__p_p_f_p_void_size_t__p_void,
  &_swigt__p_p_f_size_t__p_void,
  &_swigt__p_p_p__xmlNs,
  &_swigt__p_p_unsigned_char,
  &_swigt__p_p_void,
  &_swigt__p_unsigned_char,
  &_swigt__p_unsigned_int,
  &_swigt__p_unsigned_long,
  &_swigt__p_void,
  &_swigt__p_xlinkActuate,
  &_swigt__p_xlinkShow,
  &_swigt__p_xlinkType,
  &_swigt__p_xmlAttributeDefault,
  &_swigt__p_xmlAttributeType,
  &_swigt__p_xmlBufferAllocationScheme,
  &_swigt__p_xmlCatalogAllow,
  &_swigt__p_xmlCatalogPrefer,
  &_swigt__p_xmlCharEncError,
  &_swigt__p_xmlCharEncoding,
  &_swigt__p_xmlDocProperties,
  &_swigt__p_xmlElementContentOccur,
  &_swigt__p_xmlElementContentType,
  &_swigt__p_xmlElementType,
  &_swigt__p_xmlElementTypeVal,
  &_swigt__p_xmlEntityType,
  &_swigt__p_xmlErrorDomain,
  &_swigt__p_xmlErrorLevel,
  &_swigt__p_xmlFeature,
  &_swigt__p_xmlModuleOption,
  &_swigt__p_xmlParserErrors,
  &_swigt__p_xmlParserInputState,
  &_swigt__p_xmlParserMode,
  &_swigt__p_xmlParserOption,
  &_swigt__p_xmlParserProperties,
  &_swigt__p_xmlParserSeverities,
  &_swigt__p_xmlPatternFlags,
  &_swigt__p_xmlReaderTypes,
  &_swigt__p_xmlRelaxNGParserFlag,
  &_swigt__p_xmlRelaxNGValidErr,
  &_swigt__p_xmlSaveOption,
  &_swigt__p_xmlSchemaContentType,
  &_swigt__p_xmlSchemaTypeType,
  &_swigt__p_xmlSchemaValType,
  &_swigt__p_xmlSchemaValidError,
  &_swigt__p_xmlSchemaValidOption,
  &_swigt__p_xmlSchemaWhitespaceValueType,
  &_swigt__p_xmlTextReaderMode,
  &_swigt__p_xmlXPathError,
  &_swigt__p_xmlXPathObjectType,
};

static swig_cast_info _swigc__p_FILE[] = {  {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__htmlElemDesc[] = {  {&_swigt__p__htmlElemDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__htmlEntityDesc[] = {  {&_swigt__p__htmlEntityDesc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xlinkHandler[] = {  {&_swigt__p__xlinkHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlAttr[] = {  {&_swigt__p__xmlAttr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlAttrHashBucket[] = {  {&_swigt__p__xmlAttrHashBucket, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlAttribute[] = {  {&_swigt__p__xmlAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlAutomata[] = {  {&_swigt__p__xmlAutomata, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlAutomataState[] = {  {&_swigt__p__xmlAutomataState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlBuf[] = {  {&_swigt__p__xmlBuf, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlBuffer[] = {  {&_swigt__p__xmlBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlCatalog[] = {  {&_swigt__p__xmlCatalog, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlChLRange[] = {  {&_swigt__p__xmlChLRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlChRangeGroup[] = {  {&_swigt__p__xmlChRangeGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlChSRange[] = {  {&_swigt__p__xmlChSRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlCharEncodingHandler[] = {  {&_swigt__p__xmlCharEncodingHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlDOMWrapCtxt[] = {  {&_swigt__p__xmlDOMWrapCtxt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlDict[] = {  {&_swigt__p__xmlDict, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlDoc[] = {  {&_swigt__p__xmlDoc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlDtd[] = {  {&_swigt__p__xmlDtd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlElement[] = {  {&_swigt__p__xmlElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlElementContent[] = {  {&_swigt__p__xmlElementContent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlEntity[] = {  {&_swigt__p__xmlEntity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlEnumeration[] = {  {&_swigt__p__xmlEnumeration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlError[] = {  {&_swigt__p__xmlError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlGlobalState[] = {  {&_swigt__p__xmlGlobalState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlHashTable[] = {  {&_swigt__p__xmlHashTable, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlID[] = {  {&_swigt__p__xmlID, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlLink[] = {  {&_swigt__p__xmlLink, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlList[] = {  {&_swigt__p__xmlList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlModule[] = {  {&_swigt__p__xmlModule, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlMutex[] = {  {&_swigt__p__xmlMutex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlNode[] = {  {&_swigt__p__xmlNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlNodeSet[] = {  {&_swigt__p__xmlNodeSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlNotation[] = {  {&_swigt__p__xmlNotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlNs[] = {  {&_swigt__p__xmlNs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlOutputBuffer[] = {  {&_swigt__p__xmlOutputBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlParserCtxt[] = {  {&_swigt__p__xmlParserCtxt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlParserInput[] = {  {&_swigt__p__xmlParserInput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlParserInputBuffer[] = {  {&_swigt__p__xmlParserInputBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlParserNodeInfo[] = {  {&_swigt__p__xmlParserNodeInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlParserNodeInfoSeq[] = {  {&_swigt__p__xmlParserNodeInfoSeq, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlParserNsData[] = {  {&_swigt__p__xmlParserNsData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlPattern[] = {  {&_swigt__p__xmlPattern, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlRMutex[] = {  {&_swigt__p__xmlRMutex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlRef[] = {  {&_swigt__p__xmlRef, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlRegExecCtxt[] = {  {&_swigt__p__xmlRegExecCtxt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlRegexp[] = {  {&_swigt__p__xmlRegexp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlRelaxNG[] = {  {&_swigt__p__xmlRelaxNG, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlRelaxNGParserCtxt[] = {  {&_swigt__p__xmlRelaxNGParserCtxt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlRelaxNGValidCtxt[] = {  {&_swigt__p__xmlRelaxNGValidCtxt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSAXHandler[] = {  {&_swigt__p__xmlSAXHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSAXHandlerV1[] = {  {&_swigt__p__xmlSAXHandlerV1, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSAXLocator[] = {  {&_swigt__p__xmlSAXLocator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSaveCtxt[] = {  {&_swigt__p__xmlSaveCtxt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSchema[] = {  {&_swigt__p__xmlSchema, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSchemaAnnot[] = {  {&_swigt__p__xmlSchemaAnnot, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSchemaAttribute[] = {  {&_swigt__p__xmlSchemaAttribute, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSchemaAttributeGroup[] = {  {&_swigt__p__xmlSchemaAttributeGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSchemaAttributeLink[] = {  {&_swigt__p__xmlSchemaAttributeLink, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSchemaElement[] = {  {&_swigt__p__xmlSchemaElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSchemaFacet[] = {  {&_swigt__p__xmlSchemaFacet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSchemaFacetLink[] = {  {&_swigt__p__xmlSchemaFacetLink, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSchemaNotation[] = {  {&_swigt__p__xmlSchemaNotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSchemaParserCtxt[] = {  {&_swigt__p__xmlSchemaParserCtxt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSchemaSAXPlug[] = {  {&_swigt__p__xmlSchemaSAXPlug, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSchemaType[] = {  {&_swigt__p__xmlSchemaType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSchemaTypeLink[] = {  {&_swigt__p__xmlSchemaTypeLink, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSchemaVal[] = {  {&_swigt__p__xmlSchemaVal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSchemaValidCtxt[] = {  {&_swigt__p__xmlSchemaValidCtxt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSchemaWildcard[] = {  {&_swigt__p__xmlSchemaWildcard, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlSchemaWildcardNs[] = {  {&_swigt__p__xmlSchemaWildcardNs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlStartTag[] = {  {&_swigt__p__xmlStartTag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlStreamCtxt[] = {  {&_swigt__p__xmlStreamCtxt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlTextReader[] = {  {&_swigt__p__xmlTextReader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlTextWriter[] = {  {&_swigt__p__xmlTextWriter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlURI[] = {  {&_swigt__p__xmlURI, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlValidCtxt[] = {  {&_swigt__p__xmlValidCtxt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlValidState[] = {  {&_swigt__p__xmlValidState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlXIncludeCtxt[] = {  {&_swigt__p__xmlXIncludeCtxt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlXPathAxis[] = {  {&_swigt__p__xmlXPathAxis, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlXPathCompExpr[] = {  {&_swigt__p__xmlXPathCompExpr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlXPathContext[] = {  {&_swigt__p__xmlXPathContext, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlXPathFunct[] = {  {&_swigt__p__xmlXPathFunct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlXPathObject[] = {  {&_swigt__p__xmlXPathObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlXPathParserContext[] = {  {&_swigt__p__xmlXPathParserContext, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlXPathType[] = {  {&_swigt__p__xmlXPathType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlXPathVariable[] = {  {&_swigt__p__xmlXPathVariable, 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_f_p__xmlLink__void[] = {  {&_swigt__p_f_p__xmlLink__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p__xmlNode__void[] = {  {&_swigt__p_f_p__xmlNode__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p__xmlRegExecCtxt_p_q_const__unsigned_char_p_void_p_void__void[] = {  {&_swigt__p_f_p__xmlRegExecCtxt_p_q_const__unsigned_char_p_void_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p__xmlXPathObject_int__int[] = {  {&_swigt__p_f_p__xmlXPathObject_int__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p__xmlXPathParserContext_int__void[] = {  {&_swigt__p_f_p__xmlXPathParserContext_int__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char__int[] = {  {&_swigt__p_f_p_q_const__char__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char__p_char[] = {  {&_swigt__p_f_p_q_const__char__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char__p_void[] = {  {&_swigt__p_f_p_q_const__char__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_p_q_const__char_xmlParserCtxtPtr__p__xmlParserInput[] = {  {&_swigt__p_f_p_q_const__char_p_q_const__char_xmlParserCtxtPtr__p__xmlParserInput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer[] = {  {&_swigt__p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer[] = {  {&_swigt__p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__void_p_q_const__void__int[] = {  {&_swigt__p_f_p_q_const__void_p_q_const__void__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__void_p_void__int[] = {  {&_swigt__p_f_p_q_const__void_p_void__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_unsigned_char__void[] = {  {&_swigt__p_f_p_unsigned_char__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_unsigned_char_p_int_p_q_const__unsigned_char_p_int__int[] = {  {&_swigt__p_f_p_unsigned_char_p_int_p_q_const__unsigned_char_p_int__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void__int[] = {  {&_swigt__p_f_p_void__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void__p_unsigned_char[] = {  {&_swigt__p_f_p_void__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void__void[] = {  {&_swigt__p_f_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p__xmlNode__void[] = {  {&_swigt__p_f_p_void_p__xmlNode__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void[] = {  {&_swigt__p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_p_enum_xlinkShow_p_enum_xlinkActuate_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void[] = {  {&_swigt__p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_p_enum_xlinkShow_p_enum_xlinkActuate_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p__xmlNode_q_const__p_unsigned_char_q_const__p_unsigned_char_q_const__p_unsigned_char__void[] = {  {&_swigt__p_f_p_void_p__xmlNode_q_const__p_unsigned_char_q_const__p_unsigned_char_q_const__p_unsigned_char__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p__xmlSAXLocator__void[] = {  {&_swigt__p_f_p_void_p__xmlSAXLocator__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_char_int__int[] = {  {&_swigt__p_f_p_void_p_char_int__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_p_q_const__char_p_unsigned_long__int[] = {  {&_swigt__p_f_p_void_p_p_q_const__char_p_unsigned_long__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const___xmlError__void[] = {  {&_swigt__p_f_p_void_p_q_const___xmlError__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__char_enum_xmlParserSeverities_p_void__void[] = {  {&_swigt__p_f_p_void_p_q_const__char_enum_xmlParserSeverities_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__char_int__int[] = {  {&_swigt__p_f_p_void_p_q_const__char_int__int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__char_v_______void[] = {  {&_swigt__p_f_p_void_p_q_const__char_v_______void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__unsigned_char__p_void[] = {  {&_swigt__p_f_p_void_p_q_const__unsigned_char__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__unsigned_char__void[] = {  {&_swigt__p_f_p_void_p_q_const__unsigned_char__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__unsigned_char_int__void[] = {  {&_swigt__p_f_p_void_p_q_const__unsigned_char_int__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__unsigned_char_int_p__xmlElementContent__void[] = {  {&_swigt__p_f_p_void_p_q_const__unsigned_char_int_p__xmlElementContent__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__unsigned_char_int_p_q_const__unsigned_char_p_q_const__unsigned_char_p_unsigned_char__void[] = {  {&_swigt__p_f_p_void_p_q_const__unsigned_char_int_p_q_const__unsigned_char_p_q_const__unsigned_char_p_unsigned_char__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__unsigned_char_p_p_q_const__unsigned_char__void[] = {  {&_swigt__p_f_p_void_p_q_const__unsigned_char_p_p_q_const__unsigned_char__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__p_f_p__xmlXPathParserContext_int__void[] = {  {&_swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__p_f_p__xmlXPathParserContext_int__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__void[] = {  {&_swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_int_int_p_q_const__unsigned_char_p__xmlEnumeration__void[] = {  {&_swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_int_int_p_q_const__unsigned_char_p__xmlEnumeration__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void[] = {  {&_swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_int_p_p_q_const__unsigned_char_int_int_p_p_q_const__unsigned_char__void[] = {  {&_swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_int_p_p_q_const__unsigned_char_int_int_p_p_q_const__unsigned_char__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void[] = {  {&_swigt__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__xmlChar__p__xmlEntity[] = {  {&_swigt__p_f_p_void_p_q_const__xmlChar__p__xmlEntity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlParserInput[] = {  {&_swigt__p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlParserInput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlXPathObject[] = {  {&_swigt__p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlXPathObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_void_p_q_const__unsigned_char__void[] = {  {&_swigt__p_f_p_void_p_void_p_q_const__unsigned_char__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void[] = {  {&_swigt__p_f_p_void_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_void_size_t__p_void[] = {  {&_swigt__p_f_p_void_size_t__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_size_t__p_void[] = {  {&_swigt__p_f_size_t__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_xmlDOMWrapCtxtPtr_xmlNodePtr_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlNs[] = {  {&_swigt__p_f_xmlDOMWrapCtxtPtr_xmlNodePtr_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlNs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_xmlXPathParserContextPtr_xmlXPathObjectPtr__p__xmlXPathObject[] = {  {&_swigt__p_f_xmlXPathParserContextPtr_xmlXPathObjectPtr__p__xmlXPathObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_htmlParserOption[] = {  {&_swigt__p_htmlParserOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_htmlStatus[] = {  {&_swigt__p_htmlStatus, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iconv_t[] = {  {&_swigt__p_iconv_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__xmlCharEncodingHandler[] = {  {&_swigt__p_p__xmlCharEncodingHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__xmlDoc[] = {  {&_swigt__p_p__xmlDoc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__xmlElementContent[] = {  {&_swigt__p_p__xmlElementContent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__xmlEntity[] = {  {&_swigt__p_p__xmlEntity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__xmlEnumeration[] = {  {&_swigt__p_p__xmlEnumeration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__xmlNode[] = {  {&_swigt__p_p__xmlNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__xmlNs[] = {  {&_swigt__p_p__xmlNs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__xmlParserCtxt[] = {  {&_swigt__p_p__xmlParserCtxt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__xmlParserInput[] = {  {&_swigt__p_p__xmlParserInput, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__xmlPattern[] = {  {&_swigt__p_p__xmlPattern, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__xmlSAXHandler[] = {  {&_swigt__p_p__xmlSAXHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__xmlSchemaAttributeLink[] = {  {&_swigt__p_p__xmlSchemaAttributeLink, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__xmlSchemaVal[] = {  {&_swigt__p_p__xmlSchemaVal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__xmlURI[] = {  {&_swigt__p_p__xmlURI, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p__xmlXPathObject[] = {  {&_swigt__p_p__xmlXPathObject, 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_f_p__xmlNode__void[] = {  {&_swigt__p_p_f_p__xmlNode__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_q_const__char__p_char[] = {  {&_swigt__p_p_f_p_q_const__char__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer[] = {  {&_swigt__p_p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer[] = {  {&_swigt__p_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_void__void[] = {  {&_swigt__p_p_f_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_void_p_q_const___xmlError__void[] = {  {&_swigt__p_p_f_p_void_p_q_const___xmlError__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_void_p_q_const__char_enum_xmlParserSeverities_p_void__void[] = {  {&_swigt__p_p_f_p_void_p_q_const__char_enum_xmlParserSeverities_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_void_p_q_const__char_v_______void[] = {  {&_swigt__p_p_f_p_void_p_q_const__char_v_______void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_p_void_size_t__p_void[] = {  {&_swigt__p_p_f_p_void_size_t__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_f_size_t__p_void[] = {  {&_swigt__p_p_f_size_t__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_p__xmlNs[] = {  {&_swigt__p_p_p__xmlNs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_unsigned_char[] = {  {&_swigt__p_p_unsigned_char, 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_unsigned_char[] = {  {&_swigt__p_unsigned_char, 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_long[] = {  {&_swigt__p_unsigned_long, 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 _swigc__p_xlinkActuate[] = {  {&_swigt__p_xlinkActuate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xlinkShow[] = {  {&_swigt__p_xlinkShow, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xlinkType[] = {  {&_swigt__p_xlinkType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlAttributeDefault[] = {  {&_swigt__p_xmlAttributeDefault, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlAttributeType[] = {  {&_swigt__p_xmlAttributeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlBufferAllocationScheme[] = {  {&_swigt__p_xmlBufferAllocationScheme, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlCatalogAllow[] = {  {&_swigt__p_xmlCatalogAllow, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlCatalogPrefer[] = {  {&_swigt__p_xmlCatalogPrefer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlCharEncError[] = {  {&_swigt__p_xmlCharEncError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlCharEncoding[] = {  {&_swigt__p_xmlCharEncoding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlDocProperties[] = {  {&_swigt__p_xmlDocProperties, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlElementContentOccur[] = {  {&_swigt__p_xmlElementContentOccur, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlElementContentType[] = {  {&_swigt__p_xmlElementContentType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlElementType[] = {  {&_swigt__p_xmlElementType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlElementTypeVal[] = {  {&_swigt__p_xmlElementTypeVal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlEntityType[] = {  {&_swigt__p_xmlEntityType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlErrorDomain[] = {  {&_swigt__p_xmlErrorDomain, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlErrorLevel[] = {  {&_swigt__p_xmlErrorLevel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlFeature[] = {  {&_swigt__p_xmlFeature, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlModuleOption[] = {  {&_swigt__p_xmlModuleOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlParserErrors[] = {  {&_swigt__p_xmlParserErrors, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlParserInputState[] = {  {&_swigt__p_xmlParserInputState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlParserMode[] = {  {&_swigt__p_xmlParserMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlParserOption[] = {  {&_swigt__p_xmlParserOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlParserProperties[] = {  {&_swigt__p_xmlParserProperties, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlParserSeverities[] = {  {&_swigt__p_xmlParserSeverities, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlPatternFlags[] = {  {&_swigt__p_xmlPatternFlags, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlReaderTypes[] = {  {&_swigt__p_xmlReaderTypes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlRelaxNGParserFlag[] = {  {&_swigt__p_xmlRelaxNGParserFlag, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlRelaxNGValidErr[] = {  {&_swigt__p_xmlRelaxNGValidErr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlSaveOption[] = {  {&_swigt__p_xmlSaveOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlSchemaContentType[] = {  {&_swigt__p_xmlSchemaContentType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlSchemaTypeType[] = {  {&_swigt__p_xmlSchemaTypeType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlSchemaValType[] = {  {&_swigt__p_xmlSchemaValType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlSchemaValidError[] = {  {&_swigt__p_xmlSchemaValidError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlSchemaValidOption[] = {  {&_swigt__p_xmlSchemaValidOption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlSchemaWhitespaceValueType[] = {  {&_swigt__p_xmlSchemaWhitespaceValueType, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlTextReaderMode[] = {  {&_swigt__p_xmlTextReaderMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlXPathError[] = {  {&_swigt__p_xmlXPathError, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_xmlXPathObjectType[] = {  {&_swigt__p_xmlXPathObjectType, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_FILE,
  _swigc__p__htmlElemDesc,
  _swigc__p__htmlEntityDesc,
  _swigc__p__xlinkHandler,
  _swigc__p__xmlAttr,
  _swigc__p__xmlAttrHashBucket,
  _swigc__p__xmlAttribute,
  _swigc__p__xmlAutomata,
  _swigc__p__xmlAutomataState,
  _swigc__p__xmlBuf,
  _swigc__p__xmlBuffer,
  _swigc__p__xmlCatalog,
  _swigc__p__xmlChLRange,
  _swigc__p__xmlChRangeGroup,
  _swigc__p__xmlChSRange,
  _swigc__p__xmlCharEncodingHandler,
  _swigc__p__xmlDOMWrapCtxt,
  _swigc__p__xmlDict,
  _swigc__p__xmlDoc,
  _swigc__p__xmlDtd,
  _swigc__p__xmlElement,
  _swigc__p__xmlElementContent,
  _swigc__p__xmlEntity,
  _swigc__p__xmlEnumeration,
  _swigc__p__xmlError,
  _swigc__p__xmlGlobalState,
  _swigc__p__xmlHashTable,
  _swigc__p__xmlID,
  _swigc__p__xmlLink,
  _swigc__p__xmlList,
  _swigc__p__xmlModule,
  _swigc__p__xmlMutex,
  _swigc__p__xmlNode,
  _swigc__p__xmlNodeSet,
  _swigc__p__xmlNotation,
  _swigc__p__xmlNs,
  _swigc__p__xmlOutputBuffer,
  _swigc__p__xmlParserCtxt,
  _swigc__p__xmlParserInput,
  _swigc__p__xmlParserInputBuffer,
  _swigc__p__xmlParserNodeInfo,
  _swigc__p__xmlParserNodeInfoSeq,
  _swigc__p__xmlParserNsData,
  _swigc__p__xmlPattern,
  _swigc__p__xmlRMutex,
  _swigc__p__xmlRef,
  _swigc__p__xmlRegExecCtxt,
  _swigc__p__xmlRegexp,
  _swigc__p__xmlRelaxNG,
  _swigc__p__xmlRelaxNGParserCtxt,
  _swigc__p__xmlRelaxNGValidCtxt,
  _swigc__p__xmlSAXHandler,
  _swigc__p__xmlSAXHandlerV1,
  _swigc__p__xmlSAXLocator,
  _swigc__p__xmlSaveCtxt,
  _swigc__p__xmlSchema,
  _swigc__p__xmlSchemaAnnot,
  _swigc__p__xmlSchemaAttribute,
  _swigc__p__xmlSchemaAttributeGroup,
  _swigc__p__xmlSchemaAttributeLink,
  _swigc__p__xmlSchemaElement,
  _swigc__p__xmlSchemaFacet,
  _swigc__p__xmlSchemaFacetLink,
  _swigc__p__xmlSchemaNotation,
  _swigc__p__xmlSchemaParserCtxt,
  _swigc__p__xmlSchemaSAXPlug,
  _swigc__p__xmlSchemaType,
  _swigc__p__xmlSchemaTypeLink,
  _swigc__p__xmlSchemaVal,
  _swigc__p__xmlSchemaValidCtxt,
  _swigc__p__xmlSchemaWildcard,
  _swigc__p__xmlSchemaWildcardNs,
  _swigc__p__xmlStartTag,
  _swigc__p__xmlStreamCtxt,
  _swigc__p__xmlTextReader,
  _swigc__p__xmlTextWriter,
  _swigc__p__xmlURI,
  _swigc__p__xmlValidCtxt,
  _swigc__p__xmlValidState,
  _swigc__p__xmlXIncludeCtxt,
  _swigc__p__xmlXPathAxis,
  _swigc__p__xmlXPathCompExpr,
  _swigc__p__xmlXPathContext,
  _swigc__p__xmlXPathFunct,
  _swigc__p__xmlXPathObject,
  _swigc__p__xmlXPathParserContext,
  _swigc__p__xmlXPathType,
  _swigc__p__xmlXPathVariable,
  _swigc__p_char,
  _swigc__p_f_p__xmlLink__void,
  _swigc__p_f_p__xmlNode__void,
  _swigc__p_f_p__xmlRegExecCtxt_p_q_const__unsigned_char_p_void_p_void__void,
  _swigc__p_f_p__xmlXPathObject_int__int,
  _swigc__p_f_p__xmlXPathParserContext_int__void,
  _swigc__p_f_p_q_const__char__int,
  _swigc__p_f_p_q_const__char__p_char,
  _swigc__p_f_p_q_const__char__p_void,
  _swigc__p_f_p_q_const__char_p_q_const__char_xmlParserCtxtPtr__p__xmlParserInput,
  _swigc__p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer,
  _swigc__p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer,
  _swigc__p_f_p_q_const__void_p_q_const__void__int,
  _swigc__p_f_p_q_const__void_p_void__int,
  _swigc__p_f_p_unsigned_char__void,
  _swigc__p_f_p_unsigned_char_p_int_p_q_const__unsigned_char_p_int__int,
  _swigc__p_f_p_void__int,
  _swigc__p_f_p_void__p_unsigned_char,
  _swigc__p_f_p_void__void,
  _swigc__p_f_p_void_p__xmlNode__void,
  _swigc__p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void,
  _swigc__p_f_p_void_p__xmlNode_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_int_p_q_const__p_unsigned_char_p_q_const__p_unsigned_char_p_enum_xlinkShow_p_enum_xlinkActuate_int_p_q_const__p_unsigned_char_p_p_q_const__unsigned_char__void,
  _swigc__p_f_p_void_p__xmlNode_q_const__p_unsigned_char_q_const__p_unsigned_char_q_const__p_unsigned_char__void,
  _swigc__p_f_p_void_p__xmlSAXLocator__void,
  _swigc__p_f_p_void_p_char_int__int,
  _swigc__p_f_p_void_p_p_q_const__char_p_unsigned_long__int,
  _swigc__p_f_p_void_p_q_const___xmlError__void,
  _swigc__p_f_p_void_p_q_const__char_enum_xmlParserSeverities_p_void__void,
  _swigc__p_f_p_void_p_q_const__char_int__int,
  _swigc__p_f_p_void_p_q_const__char_v_______void,
  _swigc__p_f_p_void_p_q_const__unsigned_char__p_void,
  _swigc__p_f_p_void_p_q_const__unsigned_char__void,
  _swigc__p_f_p_void_p_q_const__unsigned_char_int__void,
  _swigc__p_f_p_void_p_q_const__unsigned_char_int_p__xmlElementContent__void,
  _swigc__p_f_p_void_p_q_const__unsigned_char_int_p_q_const__unsigned_char_p_q_const__unsigned_char_p_unsigned_char__void,
  _swigc__p_f_p_void_p_q_const__unsigned_char_p_p_q_const__unsigned_char__void,
  _swigc__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__p_f_p__xmlXPathParserContext_int__void,
  _swigc__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__void,
  _swigc__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_int_int_p_q_const__unsigned_char_p__xmlEnumeration__void,
  _swigc__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void,
  _swigc__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_int_p_p_q_const__unsigned_char_int_int_p_p_q_const__unsigned_char__void,
  _swigc__p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void,
  _swigc__p_f_p_void_p_q_const__xmlChar__p__xmlEntity,
  _swigc__p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlParserInput,
  _swigc__p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlXPathObject,
  _swigc__p_f_p_void_p_void_p_q_const__unsigned_char__void,
  _swigc__p_f_p_void_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char_p_q_const__unsigned_char__void,
  _swigc__p_f_p_void_size_t__p_void,
  _swigc__p_f_size_t__p_void,
  _swigc__p_f_xmlDOMWrapCtxtPtr_xmlNodePtr_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlNs,
  _swigc__p_f_xmlXPathParserContextPtr_xmlXPathObjectPtr__p__xmlXPathObject,
  _swigc__p_htmlParserOption,
  _swigc__p_htmlStatus,
  _swigc__p_iconv_t,
  _swigc__p_int,
  _swigc__p_p__xmlCharEncodingHandler,
  _swigc__p_p__xmlDoc,
  _swigc__p_p__xmlElementContent,
  _swigc__p_p__xmlEntity,
  _swigc__p_p__xmlEnumeration,
  _swigc__p_p__xmlNode,
  _swigc__p_p__xmlNs,
  _swigc__p_p__xmlParserCtxt,
  _swigc__p_p__xmlParserInput,
  _swigc__p_p__xmlPattern,
  _swigc__p_p__xmlSAXHandler,
  _swigc__p_p__xmlSchemaAttributeLink,
  _swigc__p_p__xmlSchemaVal,
  _swigc__p_p__xmlURI,
  _swigc__p_p__xmlXPathObject,
  _swigc__p_p_char,
  _swigc__p_p_f_p__xmlNode__void,
  _swigc__p_p_f_p_q_const__char__p_char,
  _swigc__p_p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer,
  _swigc__p_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer,
  _swigc__p_p_f_p_void__void,
  _swigc__p_p_f_p_void_p_q_const___xmlError__void,
  _swigc__p_p_f_p_void_p_q_const__char_enum_xmlParserSeverities_p_void__void,
  _swigc__p_p_f_p_void_p_q_const__char_v_______void,
  _swigc__p_p_f_p_void_size_t__p_void,
  _swigc__p_p_f_size_t__p_void,
  _swigc__p_p_p__xmlNs,
  _swigc__p_p_unsigned_char,
  _swigc__p_p_void,
  _swigc__p_unsigned_char,
  _swigc__p_unsigned_int,
  _swigc__p_unsigned_long,
  _swigc__p_void,
  _swigc__p_xlinkActuate,
  _swigc__p_xlinkShow,
  _swigc__p_xlinkType,
  _swigc__p_xmlAttributeDefault,
  _swigc__p_xmlAttributeType,
  _swigc__p_xmlBufferAllocationScheme,
  _swigc__p_xmlCatalogAllow,
  _swigc__p_xmlCatalogPrefer,
  _swigc__p_xmlCharEncError,
  _swigc__p_xmlCharEncoding,
  _swigc__p_xmlDocProperties,
  _swigc__p_xmlElementContentOccur,
  _swigc__p_xmlElementContentType,
  _swigc__p_xmlElementType,
  _swigc__p_xmlElementTypeVal,
  _swigc__p_xmlEntityType,
  _swigc__p_xmlErrorDomain,
  _swigc__p_xmlErrorLevel,
  _swigc__p_xmlFeature,
  _swigc__p_xmlModuleOption,
  _swigc__p_xmlParserErrors,
  _swigc__p_xmlParserInputState,
  _swigc__p_xmlParserMode,
  _swigc__p_xmlParserOption,
  _swigc__p_xmlParserProperties,
  _swigc__p_xmlParserSeverities,
  _swigc__p_xmlPatternFlags,
  _swigc__p_xmlReaderTypes,
  _swigc__p_xmlRelaxNGParserFlag,
  _swigc__p_xmlRelaxNGValidErr,
  _swigc__p_xmlSaveOption,
  _swigc__p_xmlSchemaContentType,
  _swigc__p_xmlSchemaTypeType,
  _swigc__p_xmlSchemaValType,
  _swigc__p_xmlSchemaValidError,
  _swigc__p_xmlSchemaValidOption,
  _swigc__p_xmlSchemaWhitespaceValueType,
  _swigc__p_xmlTextReaderMode,
  _swigc__p_xmlXPathError,
  _swigc__p_xmlXPathObjectType,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */




SWIGRUNTIME void
SWIG_V8_SetModule(v8::Local<v8::Context> context, swig_module_info *swig_module) {
  v8::Local<v8::Object> global_obj = context->Global();
  v8::Local<v8::External> mod = SWIGV8_EXTERNAL_NEW(swig_module);
  assert(!mod.IsEmpty());
  v8::Local<v8::Private> privateKey = v8::Private::ForApi(v8::Isolate::GetCurrent(), SWIGV8_STRING_NEW("swig_module_info_data"));
  global_obj->SetPrivate(context, privateKey, mod);
}

SWIGRUNTIME swig_module_info *
SWIG_V8_GetModule(v8::Local<v8::Context> context) {
  v8::Local<v8::Object> global_obj = context->Global();
  v8::Local<v8::Private> privateKey = v8::Private::ForApi(v8::Isolate::GetCurrent(), SWIGV8_STRING_NEW("swig_module_info_data"));
  v8::Local<v8::Value> moduleinfo;
  if (!global_obj->GetPrivate(context, privateKey).ToLocal(&moduleinfo))
    return 0;

  if (moduleinfo.IsEmpty() || moduleinfo->IsNull() || moduleinfo->IsUndefined())
  {
    // It's not yet loaded
    return 0;
  }

  v8::Local<v8::External> moduleinfo_extern = v8::Local<v8::External>::Cast(moduleinfo);

  if (moduleinfo_extern.IsEmpty() || moduleinfo_extern->IsNull() || moduleinfo_extern->IsUndefined())
  {
    // Something's not right
    return 0;
  }

  void *ptr = moduleinfo_extern->Value();
  assert(ptr);
  swig_module_info *retptr = static_cast<swig_module_info *>(ptr);
  assert(retptr);
  return retptr;
}

#define SWIG_GetModule(clientdata)                SWIG_V8_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer)       SWIG_V8_SetModule(clientdata, pointer)
#define SWIG_INIT_CLIENT_DATA_TYPE                v8::Local<v8::Context>


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

#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif

SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;

  /* 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);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);

    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }

  /* When multiple interpreters 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 %lu\n", (unsigned long)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 %lu %s\n", (unsigned long)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 %lu %s\n", (unsigned long)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


#if !defined(NODE_MODULE_VERSION) || (NODE_MODULE_VERSION < 12)
// Note: 'extern "C"'' disables name mangling which makes it easier to load the symbol manually
extern "C" void SWIGV8_INIT (SWIGV8_OBJECT exports_obj)
#elif (NODE_MODULE_VERSION < 64)
void SWIGV8_INIT (SWIGV8_OBJECT exports_obj, SWIGV8_VALUE /*module*/, void*)
#else
void SWIGV8_INIT (SWIGV8_OBJECT exports_obj, SWIGV8_VALUE /*module*/, v8::Local<v8::Context> context, void*)
#endif
{
#if !defined(NODE_MODULE_VERSION) || NODE_MODULE_VERSION < 64
  v8::Local<v8::Context> context = SWIGV8_CURRENT_CONTEXT();
#endif

  SWIG_InitializeModule(context);


    // populated debugxml_memory_used (see xmlmemory.h/c) and makes the call to
    // xmlMemUsed work, this must happen first!
    xmlMemSetup(xmlMemFreeWrap, xmlMemMallocWrap,
            xmlMemReallocWrap, xmlMemoryStrdupWrap);

    // initial memory usage
    xml_memory_used = xmlMemUsed();


    xmlRegisterNodeDefault(xmlRegisterNodeCallback);

    xmlDeregisterNodeDefault(xmlDeregisterNodeCallback);

    LIBXML_TEST_VERSION;


    Nan::SetMethod(exports_obj, "fromBufferAsync", fromBufferAsync);



    Nan::SetMethod(exports_obj, "withStructuredErrors", withStructuredErrors);
    Nan::SetMethod(exports_obj, "withGenericErrors", withGenericErrors);


  libxmljs::XmlSaxParser::Initialize(exports_obj);


  // a class template for creating proxies of undefined types
  SWIGV8_SET_CLASS_TEMPL(SWIGV8_SWIGTYPE_Proxy_class_templ, SWIGV8_CreateClassTemplate("SwigProxy"));

  /* create objects for namespaces */
  

  /* create class templates */
  /* Name: _exports__xmlBuffer, Type: p__xmlBuffer, Dtor: _wrap_delete__xmlBuffer */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlBuffer_class = SWIGV8_CreateClassTemplate("_exports__xmlBuffer");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlBuffer_clientData.class_templ, _exports__xmlBuffer_class);
_exports__xmlBuffer_clientData.dtor = _wrap_delete__xmlBuffer;
if (SWIGTYPE_p__xmlBuffer->clientdata == 0) {
  SWIGTYPE_p__xmlBuffer->clientdata = &_exports__xmlBuffer_clientData;
}
/* Name: _exports__xmlNotation, Type: p__xmlNotation, Dtor: _wrap_delete__xmlNotation */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlNotation_class = SWIGV8_CreateClassTemplate("_exports__xmlNotation");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlNotation_clientData.class_templ, _exports__xmlNotation_class);
_exports__xmlNotation_clientData.dtor = _wrap_delete__xmlNotation;
if (SWIGTYPE_p__xmlNotation->clientdata == 0) {
  SWIGTYPE_p__xmlNotation->clientdata = &_exports__xmlNotation_clientData;
}
/* Name: _exports__xmlEnumeration, Type: p__xmlEnumeration, Dtor: _wrap_delete__xmlEnumeration */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlEnumeration_class = SWIGV8_CreateClassTemplate("_exports__xmlEnumeration");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlEnumeration_clientData.class_templ, _exports__xmlEnumeration_class);
_exports__xmlEnumeration_clientData.dtor = _wrap_delete__xmlEnumeration;
if (SWIGTYPE_p__xmlEnumeration->clientdata == 0) {
  SWIGTYPE_p__xmlEnumeration->clientdata = &_exports__xmlEnumeration_clientData;
}
/* Name: _exports__xmlAttribute, Type: p__xmlAttribute, Dtor: _wrap_delete__xmlAttribute */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlAttribute_class = SWIGV8_CreateClassTemplate("_exports__xmlAttribute");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlAttribute_clientData.class_templ, _exports__xmlAttribute_class);
_exports__xmlAttribute_clientData.dtor = _wrap_delete__xmlAttribute;
if (SWIGTYPE_p__xmlAttribute->clientdata == 0) {
  SWIGTYPE_p__xmlAttribute->clientdata = &_exports__xmlAttribute_clientData;
}
/* Name: _exports__xmlElementContent, Type: p__xmlElementContent, Dtor: _wrap_delete__xmlElementContent */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlElementContent_class = SWIGV8_CreateClassTemplate("_exports__xmlElementContent");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlElementContent_clientData.class_templ, _exports__xmlElementContent_class);
_exports__xmlElementContent_clientData.dtor = _wrap_delete__xmlElementContent;
if (SWIGTYPE_p__xmlElementContent->clientdata == 0) {
  SWIGTYPE_p__xmlElementContent->clientdata = &_exports__xmlElementContent_clientData;
}
/* Name: _exports__xmlElement, Type: p__xmlElement, Dtor: _wrap_delete__xmlElement */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlElement_class = SWIGV8_CreateClassTemplate("_exports__xmlElement");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlElement_clientData.class_templ, _exports__xmlElement_class);
_exports__xmlElement_clientData.dtor = _wrap_delete__xmlElement;
if (SWIGTYPE_p__xmlElement->clientdata == 0) {
  SWIGTYPE_p__xmlElement->clientdata = &_exports__xmlElement_clientData;
}
/* Name: _exports__xmlNs, Type: p__xmlNs, Dtor: _wrap_delete__xmlNs */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlNs_class = SWIGV8_CreateClassTemplate("_exports__xmlNs");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlNs_clientData.class_templ, _exports__xmlNs_class);
_exports__xmlNs_clientData.dtor = _wrap_delete__xmlNs;
if (SWIGTYPE_p__xmlNs->clientdata == 0) {
  SWIGTYPE_p__xmlNs->clientdata = &_exports__xmlNs_clientData;
}
/* Name: _exports__xmlDtd, Type: p__xmlDtd, Dtor: _wrap_delete__xmlDtd */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlDtd_class = SWIGV8_CreateClassTemplate("_exports__xmlDtd");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlDtd_clientData.class_templ, _exports__xmlDtd_class);
_exports__xmlDtd_clientData.dtor = _wrap_delete__xmlDtd;
if (SWIGTYPE_p__xmlDtd->clientdata == 0) {
  SWIGTYPE_p__xmlDtd->clientdata = &_exports__xmlDtd_clientData;
}
/* Name: _exports__xmlAttr, Type: p__xmlAttr, Dtor: _wrap_delete__xmlAttr */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlAttr_class = SWIGV8_CreateClassTemplate("_exports__xmlAttr");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlAttr_clientData.class_templ, _exports__xmlAttr_class);
_exports__xmlAttr_clientData.dtor = _wrap_delete__xmlAttr;
if (SWIGTYPE_p__xmlAttr->clientdata == 0) {
  SWIGTYPE_p__xmlAttr->clientdata = &_exports__xmlAttr_clientData;
}
/* Name: _exports__xmlID, Type: p__xmlID, Dtor: _wrap_delete__xmlID */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlID_class = SWIGV8_CreateClassTemplate("_exports__xmlID");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlID_clientData.class_templ, _exports__xmlID_class);
_exports__xmlID_clientData.dtor = _wrap_delete__xmlID;
if (SWIGTYPE_p__xmlID->clientdata == 0) {
  SWIGTYPE_p__xmlID->clientdata = &_exports__xmlID_clientData;
}
/* Name: _exports__xmlRef, Type: p__xmlRef, Dtor: _wrap_delete__xmlRef */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlRef_class = SWIGV8_CreateClassTemplate("_exports__xmlRef");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlRef_clientData.class_templ, _exports__xmlRef_class);
_exports__xmlRef_clientData.dtor = _wrap_delete__xmlRef;
if (SWIGTYPE_p__xmlRef->clientdata == 0) {
  SWIGTYPE_p__xmlRef->clientdata = &_exports__xmlRef_clientData;
}
/* Name: _exports__xmlNode, Type: p__xmlNode, Dtor: _wrap_delete__xmlNode */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlNode_class = SWIGV8_CreateClassTemplate("_exports__xmlNode");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlNode_clientData.class_templ, _exports__xmlNode_class);
_exports__xmlNode_clientData.dtor = _wrap_delete__xmlNode;
if (SWIGTYPE_p__xmlNode->clientdata == 0) {
  SWIGTYPE_p__xmlNode->clientdata = &_exports__xmlNode_clientData;
}
/* Name: _exports__xmlDoc, Type: p__xmlDoc, Dtor: _wrap_delete__xmlDoc */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlDoc_class = SWIGV8_CreateClassTemplate("_exports__xmlDoc");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlDoc_clientData.class_templ, _exports__xmlDoc_class);
_exports__xmlDoc_clientData.dtor = _wrap_delete__xmlDoc;
if (SWIGTYPE_p__xmlDoc->clientdata == 0) {
  SWIGTYPE_p__xmlDoc->clientdata = &_exports__xmlDoc_clientData;
}
/* Name: _exports__xmlDOMWrapCtxt, Type: p__xmlDOMWrapCtxt, Dtor: _wrap_delete__xmlDOMWrapCtxt */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlDOMWrapCtxt_class = SWIGV8_CreateClassTemplate("_exports__xmlDOMWrapCtxt");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlDOMWrapCtxt_clientData.class_templ, _exports__xmlDOMWrapCtxt_class);
_exports__xmlDOMWrapCtxt_clientData.dtor = _wrap_delete__xmlDOMWrapCtxt;
if (SWIGTYPE_p__xmlDOMWrapCtxt->clientdata == 0) {
  SWIGTYPE_p__xmlDOMWrapCtxt->clientdata = &_exports__xmlDOMWrapCtxt_clientData;
}
/* Name: _exports__xmlError, Type: p__xmlError, Dtor: _wrap_delete__xmlError */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlError_class = SWIGV8_CreateClassTemplate("_exports__xmlError");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlError_clientData.class_templ, _exports__xmlError_class);
_exports__xmlError_clientData.dtor = _wrap_delete__xmlError;
if (SWIGTYPE_p__xmlError->clientdata == 0) {
  SWIGTYPE_p__xmlError->clientdata = &_exports__xmlError_clientData;
}
/* Name: _exports__xmlValidCtxt, Type: p__xmlValidCtxt, Dtor: _wrap_delete__xmlValidCtxt */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlValidCtxt_class = SWIGV8_CreateClassTemplate("_exports__xmlValidCtxt");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlValidCtxt_clientData.class_templ, _exports__xmlValidCtxt_class);
_exports__xmlValidCtxt_clientData.dtor = _wrap_delete__xmlValidCtxt;
if (SWIGTYPE_p__xmlValidCtxt->clientdata == 0) {
  SWIGTYPE_p__xmlValidCtxt->clientdata = &_exports__xmlValidCtxt_clientData;
}
/* Name: _exports__xmlEntity, Type: p__xmlEntity, Dtor: _wrap_delete__xmlEntity */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlEntity_class = SWIGV8_CreateClassTemplate("_exports__xmlEntity");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlEntity_clientData.class_templ, _exports__xmlEntity_class);
_exports__xmlEntity_clientData.dtor = _wrap_delete__xmlEntity;
if (SWIGTYPE_p__xmlEntity->clientdata == 0) {
  SWIGTYPE_p__xmlEntity->clientdata = &_exports__xmlEntity_clientData;
}
/* Name: _exports__xmlCharEncodingHandler, Type: p__xmlCharEncodingHandler, Dtor: _wrap_delete__xmlCharEncodingHandler */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlCharEncodingHandler_class = SWIGV8_CreateClassTemplate("_exports__xmlCharEncodingHandler");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlCharEncodingHandler_clientData.class_templ, _exports__xmlCharEncodingHandler_class);
_exports__xmlCharEncodingHandler_clientData.dtor = _wrap_delete__xmlCharEncodingHandler;
if (SWIGTYPE_p__xmlCharEncodingHandler->clientdata == 0) {
  SWIGTYPE_p__xmlCharEncodingHandler->clientdata = &_exports__xmlCharEncodingHandler_clientData;
}
/* Name: _exports__xmlParserInputBuffer, Type: p__xmlParserInputBuffer, Dtor: _wrap_delete__xmlParserInputBuffer */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlParserInputBuffer_class = SWIGV8_CreateClassTemplate("_exports__xmlParserInputBuffer");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlParserInputBuffer_clientData.class_templ, _exports__xmlParserInputBuffer_class);
_exports__xmlParserInputBuffer_clientData.dtor = _wrap_delete__xmlParserInputBuffer;
if (SWIGTYPE_p__xmlParserInputBuffer->clientdata == 0) {
  SWIGTYPE_p__xmlParserInputBuffer->clientdata = &_exports__xmlParserInputBuffer_clientData;
}
/* Name: _exports__xmlOutputBuffer, Type: p__xmlOutputBuffer, Dtor: _wrap_delete__xmlOutputBuffer */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlOutputBuffer_class = SWIGV8_CreateClassTemplate("_exports__xmlOutputBuffer");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlOutputBuffer_clientData.class_templ, _exports__xmlOutputBuffer_class);
_exports__xmlOutputBuffer_clientData.dtor = _wrap_delete__xmlOutputBuffer;
if (SWIGTYPE_p__xmlOutputBuffer->clientdata == 0) {
  SWIGTYPE_p__xmlOutputBuffer->clientdata = &_exports__xmlOutputBuffer_clientData;
}
/* Name: _exports__xmlParserInput, Type: p__xmlParserInput, Dtor: _wrap_delete__xmlParserInput */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlParserInput_class = SWIGV8_CreateClassTemplate("_exports__xmlParserInput");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlParserInput_clientData.class_templ, _exports__xmlParserInput_class);
_exports__xmlParserInput_clientData.dtor = _wrap_delete__xmlParserInput;
if (SWIGTYPE_p__xmlParserInput->clientdata == 0) {
  SWIGTYPE_p__xmlParserInput->clientdata = &_exports__xmlParserInput_clientData;
}
/* Name: _exports__xmlParserNodeInfo, Type: p__xmlParserNodeInfo, Dtor: _wrap_delete__xmlParserNodeInfo */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlParserNodeInfo_class = SWIGV8_CreateClassTemplate("_exports__xmlParserNodeInfo");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlParserNodeInfo_clientData.class_templ, _exports__xmlParserNodeInfo_class);
_exports__xmlParserNodeInfo_clientData.dtor = _wrap_delete__xmlParserNodeInfo;
if (SWIGTYPE_p__xmlParserNodeInfo->clientdata == 0) {
  SWIGTYPE_p__xmlParserNodeInfo->clientdata = &_exports__xmlParserNodeInfo_clientData;
}
/* Name: _exports__xmlParserNodeInfoSeq, Type: p__xmlParserNodeInfoSeq, Dtor: _wrap_delete__xmlParserNodeInfoSeq */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlParserNodeInfoSeq_class = SWIGV8_CreateClassTemplate("_exports__xmlParserNodeInfoSeq");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlParserNodeInfoSeq_clientData.class_templ, _exports__xmlParserNodeInfoSeq_class);
_exports__xmlParserNodeInfoSeq_clientData.dtor = _wrap_delete__xmlParserNodeInfoSeq;
if (SWIGTYPE_p__xmlParserNodeInfoSeq->clientdata == 0) {
  SWIGTYPE_p__xmlParserNodeInfoSeq->clientdata = &_exports__xmlParserNodeInfoSeq_clientData;
}
/* Name: _exports__xmlParserCtxt, Type: p__xmlParserCtxt, Dtor: _wrap_delete__xmlParserCtxt */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlParserCtxt_class = SWIGV8_CreateClassTemplate("_exports__xmlParserCtxt");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlParserCtxt_clientData.class_templ, _exports__xmlParserCtxt_class);
_exports__xmlParserCtxt_clientData.dtor = _wrap_delete__xmlParserCtxt;
if (SWIGTYPE_p__xmlParserCtxt->clientdata == 0) {
  SWIGTYPE_p__xmlParserCtxt->clientdata = &_exports__xmlParserCtxt_clientData;
}
/* Name: _exports__xmlSAXLocator, Type: p__xmlSAXLocator, Dtor: _wrap_delete__xmlSAXLocator */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSAXLocator_class = SWIGV8_CreateClassTemplate("_exports__xmlSAXLocator");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlSAXLocator_clientData.class_templ, _exports__xmlSAXLocator_class);
_exports__xmlSAXLocator_clientData.dtor = _wrap_delete__xmlSAXLocator;
if (SWIGTYPE_p__xmlSAXLocator->clientdata == 0) {
  SWIGTYPE_p__xmlSAXLocator->clientdata = &_exports__xmlSAXLocator_clientData;
}
/* Name: _exports__xmlSAXHandler, Type: p__xmlSAXHandler, Dtor: _wrap_delete__xmlSAXHandler */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSAXHandler_class = SWIGV8_CreateClassTemplate("_exports__xmlSAXHandler");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlSAXHandler_clientData.class_templ, _exports__xmlSAXHandler_class);
_exports__xmlSAXHandler_clientData.dtor = _wrap_delete__xmlSAXHandler;
if (SWIGTYPE_p__xmlSAXHandler->clientdata == 0) {
  SWIGTYPE_p__xmlSAXHandler->clientdata = &_exports__xmlSAXHandler_clientData;
}
/* Name: _exports__xmlSAXHandlerV1, Type: p__xmlSAXHandlerV1, Dtor: _wrap_delete__xmlSAXHandlerV1 */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSAXHandlerV1_class = SWIGV8_CreateClassTemplate("_exports__xmlSAXHandlerV1");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlSAXHandlerV1_clientData.class_templ, _exports__xmlSAXHandlerV1_class);
_exports__xmlSAXHandlerV1_clientData.dtor = _wrap_delete__xmlSAXHandlerV1;
if (SWIGTYPE_p__xmlSAXHandlerV1->clientdata == 0) {
  SWIGTYPE_p__xmlSAXHandlerV1->clientdata = &_exports__xmlSAXHandlerV1_clientData;
}
/* Name: _exports__xmlNodeSet, Type: p__xmlNodeSet, Dtor: _wrap_delete__xmlNodeSet */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlNodeSet_class = SWIGV8_CreateClassTemplate("_exports__xmlNodeSet");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlNodeSet_clientData.class_templ, _exports__xmlNodeSet_class);
_exports__xmlNodeSet_clientData.dtor = _wrap_delete__xmlNodeSet;
if (SWIGTYPE_p__xmlNodeSet->clientdata == 0) {
  SWIGTYPE_p__xmlNodeSet->clientdata = &_exports__xmlNodeSet_clientData;
}
/* Name: _exports__xmlXPathObject, Type: p__xmlXPathObject, Dtor: _wrap_delete__xmlXPathObject */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlXPathObject_class = SWIGV8_CreateClassTemplate("_exports__xmlXPathObject");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlXPathObject_clientData.class_templ, _exports__xmlXPathObject_class);
_exports__xmlXPathObject_clientData.dtor = _wrap_delete__xmlXPathObject;
if (SWIGTYPE_p__xmlXPathObject->clientdata == 0) {
  SWIGTYPE_p__xmlXPathObject->clientdata = &_exports__xmlXPathObject_clientData;
}
/* Name: _exports__xmlXPathType, Type: p__xmlXPathType, Dtor: _wrap_delete__xmlXPathType */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlXPathType_class = SWIGV8_CreateClassTemplate("_exports__xmlXPathType");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlXPathType_clientData.class_templ, _exports__xmlXPathType_class);
_exports__xmlXPathType_clientData.dtor = _wrap_delete__xmlXPathType;
if (SWIGTYPE_p__xmlXPathType->clientdata == 0) {
  SWIGTYPE_p__xmlXPathType->clientdata = &_exports__xmlXPathType_clientData;
}
/* Name: _exports__xmlXPathVariable, Type: p__xmlXPathVariable, Dtor: _wrap_delete__xmlXPathVariable */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlXPathVariable_class = SWIGV8_CreateClassTemplate("_exports__xmlXPathVariable");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlXPathVariable_clientData.class_templ, _exports__xmlXPathVariable_class);
_exports__xmlXPathVariable_clientData.dtor = _wrap_delete__xmlXPathVariable;
if (SWIGTYPE_p__xmlXPathVariable->clientdata == 0) {
  SWIGTYPE_p__xmlXPathVariable->clientdata = &_exports__xmlXPathVariable_clientData;
}
/* Name: _exports__xmlXPathFunct, Type: p__xmlXPathFunct, Dtor: _wrap_delete__xmlXPathFunct */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlXPathFunct_class = SWIGV8_CreateClassTemplate("_exports__xmlXPathFunct");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlXPathFunct_clientData.class_templ, _exports__xmlXPathFunct_class);
_exports__xmlXPathFunct_clientData.dtor = _wrap_delete__xmlXPathFunct;
if (SWIGTYPE_p__xmlXPathFunct->clientdata == 0) {
  SWIGTYPE_p__xmlXPathFunct->clientdata = &_exports__xmlXPathFunct_clientData;
}
/* Name: _exports__xmlXPathAxis, Type: p__xmlXPathAxis, Dtor: _wrap_delete__xmlXPathAxis */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlXPathAxis_class = SWIGV8_CreateClassTemplate("_exports__xmlXPathAxis");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlXPathAxis_clientData.class_templ, _exports__xmlXPathAxis_class);
_exports__xmlXPathAxis_clientData.dtor = _wrap_delete__xmlXPathAxis;
if (SWIGTYPE_p__xmlXPathAxis->clientdata == 0) {
  SWIGTYPE_p__xmlXPathAxis->clientdata = &_exports__xmlXPathAxis_clientData;
}
/* Name: _exports__xmlXPathContext, Type: p__xmlXPathContext, Dtor: _wrap_delete__xmlXPathContext */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlXPathContext_class = SWIGV8_CreateClassTemplate("_exports__xmlXPathContext");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlXPathContext_clientData.class_templ, _exports__xmlXPathContext_class);
_exports__xmlXPathContext_clientData.dtor = _wrap_delete__xmlXPathContext;
if (SWIGTYPE_p__xmlXPathContext->clientdata == 0) {
  SWIGTYPE_p__xmlXPathContext->clientdata = &_exports__xmlXPathContext_clientData;
}
/* Name: _exports__xmlXPathParserContext, Type: p__xmlXPathParserContext, Dtor: _wrap_delete__xmlXPathParserContext */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlXPathParserContext_class = SWIGV8_CreateClassTemplate("_exports__xmlXPathParserContext");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlXPathParserContext_clientData.class_templ, _exports__xmlXPathParserContext_class);
_exports__xmlXPathParserContext_clientData.dtor = _wrap_delete__xmlXPathParserContext;
if (SWIGTYPE_p__xmlXPathParserContext->clientdata == 0) {
  SWIGTYPE_p__xmlXPathParserContext->clientdata = &_exports__xmlXPathParserContext_clientData;
}
/* Name: _exports__xmlChSRange, Type: p__xmlChSRange, Dtor: _wrap_delete__xmlChSRange */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlChSRange_class = SWIGV8_CreateClassTemplate("_exports__xmlChSRange");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlChSRange_clientData.class_templ, _exports__xmlChSRange_class);
_exports__xmlChSRange_clientData.dtor = _wrap_delete__xmlChSRange;
if (SWIGTYPE_p__xmlChSRange->clientdata == 0) {
  SWIGTYPE_p__xmlChSRange->clientdata = &_exports__xmlChSRange_clientData;
}
/* Name: _exports__xmlChLRange, Type: p__xmlChLRange, Dtor: _wrap_delete__xmlChLRange */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlChLRange_class = SWIGV8_CreateClassTemplate("_exports__xmlChLRange");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlChLRange_clientData.class_templ, _exports__xmlChLRange_class);
_exports__xmlChLRange_clientData.dtor = _wrap_delete__xmlChLRange;
if (SWIGTYPE_p__xmlChLRange->clientdata == 0) {
  SWIGTYPE_p__xmlChLRange->clientdata = &_exports__xmlChLRange_clientData;
}
/* Name: _exports__xmlChRangeGroup, Type: p__xmlChRangeGroup, Dtor: _wrap_delete__xmlChRangeGroup */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlChRangeGroup_class = SWIGV8_CreateClassTemplate("_exports__xmlChRangeGroup");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlChRangeGroup_clientData.class_templ, _exports__xmlChRangeGroup_class);
_exports__xmlChRangeGroup_clientData.dtor = _wrap_delete__xmlChRangeGroup;
if (SWIGTYPE_p__xmlChRangeGroup->clientdata == 0) {
  SWIGTYPE_p__xmlChRangeGroup->clientdata = &_exports__xmlChRangeGroup_clientData;
}
/* Name: _exports__htmlElemDesc, Type: p__htmlElemDesc, Dtor: _wrap_delete__htmlElemDesc */
SWIGV8_FUNCTION_TEMPLATE _exports__htmlElemDesc_class = SWIGV8_CreateClassTemplate("_exports__htmlElemDesc");
SWIGV8_SET_CLASS_TEMPL(_exports__htmlElemDesc_clientData.class_templ, _exports__htmlElemDesc_class);
_exports__htmlElemDesc_clientData.dtor = _wrap_delete__htmlElemDesc;
if (SWIGTYPE_p__htmlElemDesc->clientdata == 0) {
  SWIGTYPE_p__htmlElemDesc->clientdata = &_exports__htmlElemDesc_clientData;
}
/* Name: _exports__htmlEntityDesc, Type: p__htmlEntityDesc, Dtor: _wrap_delete__htmlEntityDesc */
SWIGV8_FUNCTION_TEMPLATE _exports__htmlEntityDesc_class = SWIGV8_CreateClassTemplate("_exports__htmlEntityDesc");
SWIGV8_SET_CLASS_TEMPL(_exports__htmlEntityDesc_clientData.class_templ, _exports__htmlEntityDesc_class);
_exports__htmlEntityDesc_clientData.dtor = _wrap_delete__htmlEntityDesc;
if (SWIGTYPE_p__htmlEntityDesc->clientdata == 0) {
  SWIGTYPE_p__htmlEntityDesc->clientdata = &_exports__htmlEntityDesc_clientData;
}
/* Name: _exports__xmlURI, Type: p__xmlURI, Dtor: _wrap_delete__xmlURI */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlURI_class = SWIGV8_CreateClassTemplate("_exports__xmlURI");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlURI_clientData.class_templ, _exports__xmlURI_class);
_exports__xmlURI_clientData.dtor = _wrap_delete__xmlURI;
if (SWIGTYPE_p__xmlURI->clientdata == 0) {
  SWIGTYPE_p__xmlURI->clientdata = &_exports__xmlURI_clientData;
}
/* Name: _exports__xlinkHandler, Type: p__xlinkHandler, Dtor: _wrap_delete__xlinkHandler */
SWIGV8_FUNCTION_TEMPLATE _exports__xlinkHandler_class = SWIGV8_CreateClassTemplate("_exports__xlinkHandler");
SWIGV8_SET_CLASS_TEMPL(_exports__xlinkHandler_clientData.class_templ, _exports__xlinkHandler_class);
_exports__xlinkHandler_clientData.dtor = _wrap_delete__xlinkHandler;
if (SWIGTYPE_p__xlinkHandler->clientdata == 0) {
  SWIGTYPE_p__xlinkHandler->clientdata = &_exports__xlinkHandler_clientData;
}
/* Name: _exports__xmlSchemaAnnot, Type: p__xmlSchemaAnnot, Dtor: _wrap_delete__xmlSchemaAnnot */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaAnnot_class = SWIGV8_CreateClassTemplate("_exports__xmlSchemaAnnot");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlSchemaAnnot_clientData.class_templ, _exports__xmlSchemaAnnot_class);
_exports__xmlSchemaAnnot_clientData.dtor = _wrap_delete__xmlSchemaAnnot;
if (SWIGTYPE_p__xmlSchemaAnnot->clientdata == 0) {
  SWIGTYPE_p__xmlSchemaAnnot->clientdata = &_exports__xmlSchemaAnnot_clientData;
}
/* Name: _exports__xmlSchemaAttribute, Type: p__xmlSchemaAttribute, Dtor: _wrap_delete__xmlSchemaAttribute */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaAttribute_class = SWIGV8_CreateClassTemplate("_exports__xmlSchemaAttribute");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlSchemaAttribute_clientData.class_templ, _exports__xmlSchemaAttribute_class);
_exports__xmlSchemaAttribute_clientData.dtor = _wrap_delete__xmlSchemaAttribute;
if (SWIGTYPE_p__xmlSchemaAttribute->clientdata == 0) {
  SWIGTYPE_p__xmlSchemaAttribute->clientdata = &_exports__xmlSchemaAttribute_clientData;
}
/* Name: _exports__xmlSchemaAttributeLink, Type: p__xmlSchemaAttributeLink, Dtor: _wrap_delete__xmlSchemaAttributeLink */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaAttributeLink_class = SWIGV8_CreateClassTemplate("_exports__xmlSchemaAttributeLink");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlSchemaAttributeLink_clientData.class_templ, _exports__xmlSchemaAttributeLink_class);
_exports__xmlSchemaAttributeLink_clientData.dtor = _wrap_delete__xmlSchemaAttributeLink;
if (SWIGTYPE_p__xmlSchemaAttributeLink->clientdata == 0) {
  SWIGTYPE_p__xmlSchemaAttributeLink->clientdata = &_exports__xmlSchemaAttributeLink_clientData;
}
/* Name: _exports__xmlSchemaWildcardNs, Type: p__xmlSchemaWildcardNs, Dtor: _wrap_delete__xmlSchemaWildcardNs */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaWildcardNs_class = SWIGV8_CreateClassTemplate("_exports__xmlSchemaWildcardNs");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlSchemaWildcardNs_clientData.class_templ, _exports__xmlSchemaWildcardNs_class);
_exports__xmlSchemaWildcardNs_clientData.dtor = _wrap_delete__xmlSchemaWildcardNs;
if (SWIGTYPE_p__xmlSchemaWildcardNs->clientdata == 0) {
  SWIGTYPE_p__xmlSchemaWildcardNs->clientdata = &_exports__xmlSchemaWildcardNs_clientData;
}
/* Name: _exports__xmlSchemaWildcard, Type: p__xmlSchemaWildcard, Dtor: _wrap_delete__xmlSchemaWildcard */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaWildcard_class = SWIGV8_CreateClassTemplate("_exports__xmlSchemaWildcard");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlSchemaWildcard_clientData.class_templ, _exports__xmlSchemaWildcard_class);
_exports__xmlSchemaWildcard_clientData.dtor = _wrap_delete__xmlSchemaWildcard;
if (SWIGTYPE_p__xmlSchemaWildcard->clientdata == 0) {
  SWIGTYPE_p__xmlSchemaWildcard->clientdata = &_exports__xmlSchemaWildcard_clientData;
}
/* Name: _exports__xmlSchemaAttributeGroup, Type: p__xmlSchemaAttributeGroup, Dtor: _wrap_delete__xmlSchemaAttributeGroup */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaAttributeGroup_class = SWIGV8_CreateClassTemplate("_exports__xmlSchemaAttributeGroup");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlSchemaAttributeGroup_clientData.class_templ, _exports__xmlSchemaAttributeGroup_class);
_exports__xmlSchemaAttributeGroup_clientData.dtor = _wrap_delete__xmlSchemaAttributeGroup;
if (SWIGTYPE_p__xmlSchemaAttributeGroup->clientdata == 0) {
  SWIGTYPE_p__xmlSchemaAttributeGroup->clientdata = &_exports__xmlSchemaAttributeGroup_clientData;
}
/* Name: _exports__xmlSchemaTypeLink, Type: p__xmlSchemaTypeLink, Dtor: _wrap_delete__xmlSchemaTypeLink */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaTypeLink_class = SWIGV8_CreateClassTemplate("_exports__xmlSchemaTypeLink");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlSchemaTypeLink_clientData.class_templ, _exports__xmlSchemaTypeLink_class);
_exports__xmlSchemaTypeLink_clientData.dtor = _wrap_delete__xmlSchemaTypeLink;
if (SWIGTYPE_p__xmlSchemaTypeLink->clientdata == 0) {
  SWIGTYPE_p__xmlSchemaTypeLink->clientdata = &_exports__xmlSchemaTypeLink_clientData;
}
/* Name: _exports__xmlSchemaFacetLink, Type: p__xmlSchemaFacetLink, Dtor: _wrap_delete__xmlSchemaFacetLink */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaFacetLink_class = SWIGV8_CreateClassTemplate("_exports__xmlSchemaFacetLink");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlSchemaFacetLink_clientData.class_templ, _exports__xmlSchemaFacetLink_class);
_exports__xmlSchemaFacetLink_clientData.dtor = _wrap_delete__xmlSchemaFacetLink;
if (SWIGTYPE_p__xmlSchemaFacetLink->clientdata == 0) {
  SWIGTYPE_p__xmlSchemaFacetLink->clientdata = &_exports__xmlSchemaFacetLink_clientData;
}
/* Name: _exports__xmlSchemaType, Type: p__xmlSchemaType, Dtor: _wrap_delete__xmlSchemaType */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaType_class = SWIGV8_CreateClassTemplate("_exports__xmlSchemaType");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlSchemaType_clientData.class_templ, _exports__xmlSchemaType_class);
_exports__xmlSchemaType_clientData.dtor = _wrap_delete__xmlSchemaType;
if (SWIGTYPE_p__xmlSchemaType->clientdata == 0) {
  SWIGTYPE_p__xmlSchemaType->clientdata = &_exports__xmlSchemaType_clientData;
}
/* Name: _exports__xmlSchemaElement, Type: p__xmlSchemaElement, Dtor: _wrap_delete__xmlSchemaElement */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaElement_class = SWIGV8_CreateClassTemplate("_exports__xmlSchemaElement");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlSchemaElement_clientData.class_templ, _exports__xmlSchemaElement_class);
_exports__xmlSchemaElement_clientData.dtor = _wrap_delete__xmlSchemaElement;
if (SWIGTYPE_p__xmlSchemaElement->clientdata == 0) {
  SWIGTYPE_p__xmlSchemaElement->clientdata = &_exports__xmlSchemaElement_clientData;
}
/* Name: _exports__xmlSchemaFacet, Type: p__xmlSchemaFacet, Dtor: _wrap_delete__xmlSchemaFacet */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaFacet_class = SWIGV8_CreateClassTemplate("_exports__xmlSchemaFacet");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlSchemaFacet_clientData.class_templ, _exports__xmlSchemaFacet_class);
_exports__xmlSchemaFacet_clientData.dtor = _wrap_delete__xmlSchemaFacet;
if (SWIGTYPE_p__xmlSchemaFacet->clientdata == 0) {
  SWIGTYPE_p__xmlSchemaFacet->clientdata = &_exports__xmlSchemaFacet_clientData;
}
/* Name: _exports__xmlSchemaNotation, Type: p__xmlSchemaNotation, Dtor: _wrap_delete__xmlSchemaNotation */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaNotation_class = SWIGV8_CreateClassTemplate("_exports__xmlSchemaNotation");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlSchemaNotation_clientData.class_templ, _exports__xmlSchemaNotation_class);
_exports__xmlSchemaNotation_clientData.dtor = _wrap_delete__xmlSchemaNotation;
if (SWIGTYPE_p__xmlSchemaNotation->clientdata == 0) {
  SWIGTYPE_p__xmlSchemaNotation->clientdata = &_exports__xmlSchemaNotation_clientData;
}
/* Name: _exports__xmlSchema, Type: p__xmlSchema, Dtor: _wrap_delete__xmlSchema */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchema_class = SWIGV8_CreateClassTemplate("_exports__xmlSchema");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlSchema_clientData.class_templ, _exports__xmlSchema_class);
_exports__xmlSchema_clientData.dtor = _wrap_delete__xmlSchema;
if (SWIGTYPE_p__xmlSchema->clientdata == 0) {
  SWIGTYPE_p__xmlSchema->clientdata = &_exports__xmlSchema_clientData;
}


  /* register wrapper functions */
  SWIGV8_AddStaticVariable(exports_obj, "libxmljs_debug", _wrap_libxmljs_debug_get, _wrap_libxmljs_debug_set, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_ARPA_INET_H", exports_HAVE_ARPA_INET_H_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_ATTRIBUTE_DESTRUCTOR", exports_HAVE_ATTRIBUTE_DESTRUCTOR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_DLFCN_H", exports_HAVE_DLFCN_H_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_DLOPEN", exports_HAVE_DLOPEN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_FCNTL_H", exports_HAVE_FCNTL_H_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_FTIME", exports_HAVE_FTIME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_GETENTROPY", exports_HAVE_GETENTROPY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_GETTIMEOFDAY", exports_HAVE_GETTIMEOFDAY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_LIBREADLINE", exports_HAVE_LIBREADLINE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_MMAP", exports_HAVE_MMAP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_MUNMAP", exports_HAVE_MUNMAP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_NETDB_H", exports_HAVE_NETDB_H_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_NETINET_IN_H", exports_HAVE_NETINET_IN_H_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_POLL_H", exports_HAVE_POLL_H_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_PTHREAD_H", exports_HAVE_PTHREAD_H_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_STAT", exports_HAVE_STAT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_STDINT_H", exports_HAVE_STDINT_H_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SYS_MMAN_H", exports_HAVE_SYS_MMAN_H_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SYS_RANDOM_H", exports_HAVE_SYS_RANDOM_H_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SYS_SELECT_H", exports_HAVE_SYS_SELECT_H_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SYS_SOCKET_H", exports_HAVE_SYS_SOCKET_H_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SYS_STAT_H", exports_HAVE_SYS_STAT_H_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SYS_TIMEB_H", exports_HAVE_SYS_TIMEB_H_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SYS_TIME_H", exports_HAVE_SYS_TIME_H_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_UNISTD_H", exports_HAVE_UNISTD_H_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "VERSION", exports_VERSION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "LIBXML_DOTTED_VERSION", exports_LIBXML_DOTTED_VERSION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "LIBXML_VERSION", exports_LIBXML_VERSION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "LIBXML_VERSION_STRING", exports_LIBXML_VERSION_STRING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "LIBXML_VERSION_EXTRA", exports_LIBXML_VERSION_EXTRA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "LIBXML_MODULE_EXTENSION", exports_LIBXML_MODULE_EXTENSION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlMalloc", _wrap_xmlMalloc_get, _wrap_xmlMalloc_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlMallocAtomic", _wrap_xmlMallocAtomic_get, _wrap_xmlMallocAtomic_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlRealloc", _wrap_xmlRealloc_get, _wrap_xmlRealloc_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlFree", _wrap_xmlFree_get, _wrap_xmlFree_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlMemStrdup", _wrap_xmlMemStrdup_get, _wrap_xmlMemStrdup_set, context);
SWIGV8_AddStaticVariable(exports_obj, "BASE_BUFFER_SIZE", exports_BASE_BUFFER_SIZE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_BUFFER_ALLOC_DOUBLEIT", exports_XML_BUFFER_ALLOC_DOUBLEIT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_BUFFER_ALLOC_EXACT", exports_XML_BUFFER_ALLOC_EXACT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_BUFFER_ALLOC_IMMUTABLE", exports_XML_BUFFER_ALLOC_IMMUTABLE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_BUFFER_ALLOC_IO", exports_XML_BUFFER_ALLOC_IO_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_BUFFER_ALLOC_HYBRID", exports_XML_BUFFER_ALLOC_HYBRID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_BUFFER_ALLOC_BOUNDED", exports_XML_BUFFER_ALLOC_BOUNDED_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlBuffer_class, "content", _wrap__xmlBuffer_content_get, _wrap__xmlBuffer_content_set);
SWIGV8_AddMemberVariable(_exports__xmlBuffer_class, "use", _wrap__xmlBuffer_use_get, _wrap__xmlBuffer_use_set);
SWIGV8_AddMemberVariable(_exports__xmlBuffer_class, "size", _wrap__xmlBuffer_size_get, _wrap__xmlBuffer_size_set);
SWIGV8_AddMemberVariable(_exports__xmlBuffer_class, "alloc", _wrap__xmlBuffer_alloc_get, _wrap__xmlBuffer_alloc_set);
SWIGV8_AddMemberVariable(_exports__xmlBuffer_class, "contentIO", _wrap__xmlBuffer_contentIO_get, _wrap__xmlBuffer_contentIO_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_NODE", exports_XML_ELEMENT_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_NODE", exports_XML_ATTRIBUTE_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_TEXT_NODE", exports_XML_TEXT_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CDATA_SECTION_NODE", exports_XML_CDATA_SECTION_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ENTITY_REF_NODE", exports_XML_ENTITY_REF_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ENTITY_NODE", exports_XML_ENTITY_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PI_NODE", exports_XML_PI_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_COMMENT_NODE", exports_XML_COMMENT_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOCUMENT_NODE", exports_XML_DOCUMENT_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOCUMENT_TYPE_NODE", exports_XML_DOCUMENT_TYPE_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOCUMENT_FRAG_NODE", exports_XML_DOCUMENT_FRAG_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_NOTATION_NODE", exports_XML_NOTATION_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_HTML_DOCUMENT_NODE", exports_XML_HTML_DOCUMENT_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NODE", exports_XML_DTD_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_DECL", exports_XML_ELEMENT_DECL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_DECL", exports_XML_ATTRIBUTE_DECL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ENTITY_DECL", exports_XML_ENTITY_DECL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_NAMESPACE_DECL", exports_XML_NAMESPACE_DECL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_START", exports_XML_XINCLUDE_START_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_END", exports_XML_XINCLUDE_END_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOCB_DOCUMENT_NODE", exports_XML_DOCB_DOCUMENT_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlNotation_class, "name", _wrap__xmlNotation_name_get, _wrap__xmlNotation_name_set);
SWIGV8_AddMemberVariable(_exports__xmlNotation_class, "PublicID", _wrap__xmlNotation_PublicID_get, _wrap__xmlNotation_PublicID_set);
SWIGV8_AddMemberVariable(_exports__xmlNotation_class, "SystemID", _wrap__xmlNotation_SystemID_get, _wrap__xmlNotation_SystemID_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_CDATA", exports_XML_ATTRIBUTE_CDATA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_ID", exports_XML_ATTRIBUTE_ID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_IDREF", exports_XML_ATTRIBUTE_IDREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_IDREFS", exports_XML_ATTRIBUTE_IDREFS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_ENTITY", exports_XML_ATTRIBUTE_ENTITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_ENTITIES", exports_XML_ATTRIBUTE_ENTITIES_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_NMTOKEN", exports_XML_ATTRIBUTE_NMTOKEN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_NMTOKENS", exports_XML_ATTRIBUTE_NMTOKENS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_ENUMERATION", exports_XML_ATTRIBUTE_ENUMERATION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_NOTATION", exports_XML_ATTRIBUTE_NOTATION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_NONE", exports_XML_ATTRIBUTE_NONE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_REQUIRED", exports_XML_ATTRIBUTE_REQUIRED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_IMPLIED", exports_XML_ATTRIBUTE_IMPLIED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_FIXED", exports_XML_ATTRIBUTE_FIXED_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlEnumeration_class, "next", _wrap__xmlEnumeration_next_get, _wrap__xmlEnumeration_next_set);
SWIGV8_AddMemberVariable(_exports__xmlEnumeration_class, "name", _wrap__xmlEnumeration_name_get, _wrap__xmlEnumeration_name_set);
SWIGV8_AddMemberVariable(_exports__xmlAttribute_class, "_private", _wrap__xmlAttribute__private_get, _wrap__xmlAttribute__private_set);
SWIGV8_AddMemberVariable(_exports__xmlAttribute_class, "type", _wrap__xmlAttribute_type_get, _wrap__xmlAttribute_type_set);
SWIGV8_AddMemberVariable(_exports__xmlAttribute_class, "name", _wrap__xmlAttribute_name_get, _wrap__xmlAttribute_name_set);
SWIGV8_AddMemberVariable(_exports__xmlAttribute_class, "children", _wrap__xmlAttribute_children_get, _wrap__xmlAttribute_children_set);
SWIGV8_AddMemberVariable(_exports__xmlAttribute_class, "last", _wrap__xmlAttribute_last_get, _wrap__xmlAttribute_last_set);
SWIGV8_AddMemberVariable(_exports__xmlAttribute_class, "parent", _wrap__xmlAttribute_parent_get, _wrap__xmlAttribute_parent_set);
SWIGV8_AddMemberVariable(_exports__xmlAttribute_class, "next", _wrap__xmlAttribute_next_get, _wrap__xmlAttribute_next_set);
SWIGV8_AddMemberVariable(_exports__xmlAttribute_class, "prev", _wrap__xmlAttribute_prev_get, _wrap__xmlAttribute_prev_set);
SWIGV8_AddMemberVariable(_exports__xmlAttribute_class, "doc", _wrap__xmlAttribute_doc_get, _wrap__xmlAttribute_doc_set);
SWIGV8_AddMemberVariable(_exports__xmlAttribute_class, "nexth", _wrap__xmlAttribute_nexth_get, _wrap__xmlAttribute_nexth_set);
SWIGV8_AddMemberVariable(_exports__xmlAttribute_class, "atype", _wrap__xmlAttribute_atype_get, _wrap__xmlAttribute_atype_set);
SWIGV8_AddMemberVariable(_exports__xmlAttribute_class, "def", _wrap__xmlAttribute_def_get, _wrap__xmlAttribute_def_set);
SWIGV8_AddMemberVariable(_exports__xmlAttribute_class, "defaultValue", _wrap__xmlAttribute_defaultValue_get, _wrap__xmlAttribute_defaultValue_set);
SWIGV8_AddMemberVariable(_exports__xmlAttribute_class, "tree", _wrap__xmlAttribute_tree_get, _wrap__xmlAttribute_tree_set);
SWIGV8_AddMemberVariable(_exports__xmlAttribute_class, "prefix", _wrap__xmlAttribute_prefix_get, _wrap__xmlAttribute_prefix_set);
SWIGV8_AddMemberVariable(_exports__xmlAttribute_class, "elem", _wrap__xmlAttribute_elem_get, _wrap__xmlAttribute_elem_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_CONTENT_PCDATA", exports_XML_ELEMENT_CONTENT_PCDATA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_CONTENT_ELEMENT", exports_XML_ELEMENT_CONTENT_ELEMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_CONTENT_SEQ", exports_XML_ELEMENT_CONTENT_SEQ_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_CONTENT_OR", exports_XML_ELEMENT_CONTENT_OR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_CONTENT_ONCE", exports_XML_ELEMENT_CONTENT_ONCE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_CONTENT_OPT", exports_XML_ELEMENT_CONTENT_OPT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_CONTENT_MULT", exports_XML_ELEMENT_CONTENT_MULT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_CONTENT_PLUS", exports_XML_ELEMENT_CONTENT_PLUS_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlElementContent_class, "type", _wrap__xmlElementContent_type_get, _wrap__xmlElementContent_type_set);
SWIGV8_AddMemberVariable(_exports__xmlElementContent_class, "ocur", _wrap__xmlElementContent_ocur_get, _wrap__xmlElementContent_ocur_set);
SWIGV8_AddMemberVariable(_exports__xmlElementContent_class, "name", _wrap__xmlElementContent_name_get, _wrap__xmlElementContent_name_set);
SWIGV8_AddMemberVariable(_exports__xmlElementContent_class, "c1", _wrap__xmlElementContent_c1_get, _wrap__xmlElementContent_c1_set);
SWIGV8_AddMemberVariable(_exports__xmlElementContent_class, "c2", _wrap__xmlElementContent_c2_get, _wrap__xmlElementContent_c2_set);
SWIGV8_AddMemberVariable(_exports__xmlElementContent_class, "parent", _wrap__xmlElementContent_parent_get, _wrap__xmlElementContent_parent_set);
SWIGV8_AddMemberVariable(_exports__xmlElementContent_class, "prefix", _wrap__xmlElementContent_prefix_get, _wrap__xmlElementContent_prefix_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_TYPE_UNDEFINED", exports_XML_ELEMENT_TYPE_UNDEFINED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_TYPE_EMPTY", exports_XML_ELEMENT_TYPE_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_TYPE_ANY", exports_XML_ELEMENT_TYPE_ANY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_TYPE_MIXED", exports_XML_ELEMENT_TYPE_MIXED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_TYPE_ELEMENT", exports_XML_ELEMENT_TYPE_ELEMENT_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlElement_class, "_private", _wrap__xmlElement__private_get, _wrap__xmlElement__private_set);
SWIGV8_AddMemberVariable(_exports__xmlElement_class, "type", _wrap__xmlElement_type_get, _wrap__xmlElement_type_set);
SWIGV8_AddMemberVariable(_exports__xmlElement_class, "name", _wrap__xmlElement_name_get, _wrap__xmlElement_name_set);
SWIGV8_AddMemberVariable(_exports__xmlElement_class, "children", _wrap__xmlElement_children_get, _wrap__xmlElement_children_set);
SWIGV8_AddMemberVariable(_exports__xmlElement_class, "last", _wrap__xmlElement_last_get, _wrap__xmlElement_last_set);
SWIGV8_AddMemberVariable(_exports__xmlElement_class, "parent", _wrap__xmlElement_parent_get, _wrap__xmlElement_parent_set);
SWIGV8_AddMemberVariable(_exports__xmlElement_class, "next", _wrap__xmlElement_next_get, _wrap__xmlElement_next_set);
SWIGV8_AddMemberVariable(_exports__xmlElement_class, "prev", _wrap__xmlElement_prev_get, _wrap__xmlElement_prev_set);
SWIGV8_AddMemberVariable(_exports__xmlElement_class, "doc", _wrap__xmlElement_doc_get, _wrap__xmlElement_doc_set);
SWIGV8_AddMemberVariable(_exports__xmlElement_class, "etype", _wrap__xmlElement_etype_get, _wrap__xmlElement_etype_set);
SWIGV8_AddMemberVariable(_exports__xmlElement_class, "content", _wrap__xmlElement_content_get, _wrap__xmlElement_content_set);
SWIGV8_AddMemberVariable(_exports__xmlElement_class, "attributes", _wrap__xmlElement_attributes_get, _wrap__xmlElement_attributes_set);
SWIGV8_AddMemberVariable(_exports__xmlElement_class, "prefix", _wrap__xmlElement_prefix_get, _wrap__xmlElement_prefix_set);
SWIGV8_AddMemberVariable(_exports__xmlElement_class, "contModel", _wrap__xmlElement_contModel_get, _wrap__xmlElement_contModel_set);
SWIGV8_AddMemberVariable(_exports__xmlNs_class, "next", _wrap__xmlNs_next_get, _wrap__xmlNs_next_set);
SWIGV8_AddMemberVariable(_exports__xmlNs_class, "type", _wrap__xmlNs_type_get, _wrap__xmlNs_type_set);
SWIGV8_AddMemberVariable(_exports__xmlNs_class, "href", _wrap__xmlNs_href_get, _wrap__xmlNs_href_set);
SWIGV8_AddMemberVariable(_exports__xmlNs_class, "prefix", _wrap__xmlNs_prefix_get, _wrap__xmlNs_prefix_set);
SWIGV8_AddMemberVariable(_exports__xmlNs_class, "_private", _wrap__xmlNs__private_get, _wrap__xmlNs__private_set);
SWIGV8_AddMemberVariable(_exports__xmlNs_class, "context", _wrap__xmlNs_context_get, _wrap__xmlNs_context_set);
SWIGV8_AddMemberVariable(_exports__xmlDtd_class, "_private", _wrap__xmlDtd__private_get, _wrap__xmlDtd__private_set);
SWIGV8_AddMemberVariable(_exports__xmlDtd_class, "type", _wrap__xmlDtd_type_get, _wrap__xmlDtd_type_set);
SWIGV8_AddMemberVariable(_exports__xmlDtd_class, "name", _wrap__xmlDtd_name_get, _wrap__xmlDtd_name_set);
SWIGV8_AddMemberVariable(_exports__xmlDtd_class, "children", _wrap__xmlDtd_children_get, _wrap__xmlDtd_children_set);
SWIGV8_AddMemberVariable(_exports__xmlDtd_class, "last", _wrap__xmlDtd_last_get, _wrap__xmlDtd_last_set);
SWIGV8_AddMemberVariable(_exports__xmlDtd_class, "parent", _wrap__xmlDtd_parent_get, _wrap__xmlDtd_parent_set);
SWIGV8_AddMemberVariable(_exports__xmlDtd_class, "next", _wrap__xmlDtd_next_get, _wrap__xmlDtd_next_set);
SWIGV8_AddMemberVariable(_exports__xmlDtd_class, "prev", _wrap__xmlDtd_prev_get, _wrap__xmlDtd_prev_set);
SWIGV8_AddMemberVariable(_exports__xmlDtd_class, "doc", _wrap__xmlDtd_doc_get, _wrap__xmlDtd_doc_set);
SWIGV8_AddMemberVariable(_exports__xmlDtd_class, "notations", _wrap__xmlDtd_notations_get, _wrap__xmlDtd_notations_set);
SWIGV8_AddMemberVariable(_exports__xmlDtd_class, "elements", _wrap__xmlDtd_elements_get, _wrap__xmlDtd_elements_set);
SWIGV8_AddMemberVariable(_exports__xmlDtd_class, "attributes", _wrap__xmlDtd_attributes_get, _wrap__xmlDtd_attributes_set);
SWIGV8_AddMemberVariable(_exports__xmlDtd_class, "entities", _wrap__xmlDtd_entities_get, _wrap__xmlDtd_entities_set);
SWIGV8_AddMemberVariable(_exports__xmlDtd_class, "ExternalID", _wrap__xmlDtd_ExternalID_get, _wrap__xmlDtd_ExternalID_set);
SWIGV8_AddMemberVariable(_exports__xmlDtd_class, "SystemID", _wrap__xmlDtd_SystemID_get, _wrap__xmlDtd_SystemID_set);
SWIGV8_AddMemberVariable(_exports__xmlDtd_class, "pentities", _wrap__xmlDtd_pentities_get, _wrap__xmlDtd_pentities_set);
SWIGV8_AddMemberVariable(_exports__xmlAttr_class, "id", _wrap__xmlAttr_id_get, _wrap__xmlAttr_id_set);
SWIGV8_AddMemberVariable(_exports__xmlAttr_class, "_private", _wrap__xmlAttr__private_get, _wrap__xmlAttr__private_set);
SWIGV8_AddMemberVariable(_exports__xmlAttr_class, "type", _wrap__xmlAttr_type_get, _wrap__xmlAttr_type_set);
SWIGV8_AddMemberVariable(_exports__xmlAttr_class, "name", _wrap__xmlAttr_name_get, _wrap__xmlAttr_name_set);
SWIGV8_AddMemberVariable(_exports__xmlAttr_class, "children", _wrap__xmlAttr_children_get, _wrap__xmlAttr_children_set);
SWIGV8_AddMemberVariable(_exports__xmlAttr_class, "last", _wrap__xmlAttr_last_get, _wrap__xmlAttr_last_set);
SWIGV8_AddMemberVariable(_exports__xmlAttr_class, "parent", _wrap__xmlAttr_parent_get, _wrap__xmlAttr_parent_set);
SWIGV8_AddMemberVariable(_exports__xmlAttr_class, "next", _wrap__xmlAttr_next_get, _wrap__xmlAttr_next_set);
SWIGV8_AddMemberVariable(_exports__xmlAttr_class, "prev", _wrap__xmlAttr_prev_get, _wrap__xmlAttr_prev_set);
SWIGV8_AddMemberVariable(_exports__xmlAttr_class, "doc", _wrap__xmlAttr_doc_get, _wrap__xmlAttr_doc_set);
SWIGV8_AddMemberVariable(_exports__xmlAttr_class, "ns", _wrap__xmlAttr_ns_get, _wrap__xmlAttr_ns_set);
SWIGV8_AddMemberVariable(_exports__xmlAttr_class, "atype", _wrap__xmlAttr_atype_get, _wrap__xmlAttr_atype_set);
SWIGV8_AddMemberVariable(_exports__xmlAttr_class, "psvi", _wrap__xmlAttr_psvi_get, _wrap__xmlAttr_psvi_set);
SWIGV8_AddMemberVariable(_exports__xmlID_class, "next", _wrap__xmlID_next_get, _wrap__xmlID_next_set);
SWIGV8_AddMemberVariable(_exports__xmlID_class, "value", _wrap__xmlID_value_get, _wrap__xmlID_value_set);
SWIGV8_AddMemberVariable(_exports__xmlID_class, "attr", _wrap__xmlID_attr_get, _wrap__xmlID_attr_set);
SWIGV8_AddMemberVariable(_exports__xmlID_class, "name", _wrap__xmlID_name_get, _wrap__xmlID_name_set);
SWIGV8_AddMemberVariable(_exports__xmlID_class, "lineno", _wrap__xmlID_lineno_get, _wrap__xmlID_lineno_set);
SWIGV8_AddMemberVariable(_exports__xmlID_class, "doc", _wrap__xmlID_doc_get, _wrap__xmlID_doc_set);
SWIGV8_AddMemberVariable(_exports__xmlRef_class, "next", _wrap__xmlRef_next_get, _wrap__xmlRef_next_set);
SWIGV8_AddMemberVariable(_exports__xmlRef_class, "value", _wrap__xmlRef_value_get, _wrap__xmlRef_value_set);
SWIGV8_AddMemberVariable(_exports__xmlRef_class, "attr", _wrap__xmlRef_attr_get, _wrap__xmlRef_attr_set);
SWIGV8_AddMemberVariable(_exports__xmlRef_class, "name", _wrap__xmlRef_name_get, _wrap__xmlRef_name_set);
SWIGV8_AddMemberVariable(_exports__xmlRef_class, "lineno", _wrap__xmlRef_lineno_get, _wrap__xmlRef_lineno_set);
SWIGV8_AddMemberVariable(_exports__xmlNode_class, "_private", _wrap__xmlNode__private_get, _wrap__xmlNode__private_set);
SWIGV8_AddMemberVariable(_exports__xmlNode_class, "type", _wrap__xmlNode_type_get, _wrap__xmlNode_type_set);
SWIGV8_AddMemberVariable(_exports__xmlNode_class, "name", _wrap__xmlNode_name_get, _wrap__xmlNode_name_set);
SWIGV8_AddMemberVariable(_exports__xmlNode_class, "children", _wrap__xmlNode_children_get, _wrap__xmlNode_children_set);
SWIGV8_AddMemberVariable(_exports__xmlNode_class, "last", _wrap__xmlNode_last_get, _wrap__xmlNode_last_set);
SWIGV8_AddMemberVariable(_exports__xmlNode_class, "parent", _wrap__xmlNode_parent_get, _wrap__xmlNode_parent_set);
SWIGV8_AddMemberVariable(_exports__xmlNode_class, "next", _wrap__xmlNode_next_get, _wrap__xmlNode_next_set);
SWIGV8_AddMemberVariable(_exports__xmlNode_class, "prev", _wrap__xmlNode_prev_get, _wrap__xmlNode_prev_set);
SWIGV8_AddMemberVariable(_exports__xmlNode_class, "doc", _wrap__xmlNode_doc_get, _wrap__xmlNode_doc_set);
SWIGV8_AddMemberVariable(_exports__xmlNode_class, "ns", _wrap__xmlNode_ns_get, _wrap__xmlNode_ns_set);
SWIGV8_AddMemberVariable(_exports__xmlNode_class, "content", _wrap__xmlNode_content_get, _wrap__xmlNode_content_set);
SWIGV8_AddMemberVariable(_exports__xmlNode_class, "properties", _wrap__xmlNode_properties_get, _wrap__xmlNode_properties_set);
SWIGV8_AddMemberVariable(_exports__xmlNode_class, "nsDef", _wrap__xmlNode_nsDef_get, _wrap__xmlNode_nsDef_set);
SWIGV8_AddMemberVariable(_exports__xmlNode_class, "psvi", _wrap__xmlNode_psvi_get, _wrap__xmlNode_psvi_set);
SWIGV8_AddMemberVariable(_exports__xmlNode_class, "line", _wrap__xmlNode_line_get, _wrap__xmlNode_line_set);
SWIGV8_AddMemberVariable(_exports__xmlNode_class, "extra", _wrap__xmlNode_extra_get, _wrap__xmlNode_extra_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOC_WELLFORMED", exports_XML_DOC_WELLFORMED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOC_NSVALID", exports_XML_DOC_NSVALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOC_OLD10", exports_XML_DOC_OLD10_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOC_DTDVALID", exports_XML_DOC_DTDVALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOC_XINCLUDE", exports_XML_DOC_XINCLUDE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOC_USERBUILT", exports_XML_DOC_USERBUILT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOC_INTERNAL", exports_XML_DOC_INTERNAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOC_HTML", exports_XML_DOC_HTML_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "_private", _wrap__xmlDoc__private_get, _wrap__xmlDoc__private_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "type", _wrap__xmlDoc_type_get, _wrap__xmlDoc_type_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "name", _wrap__xmlDoc_name_get, _wrap__xmlDoc_name_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "children", _wrap__xmlDoc_children_get, _wrap__xmlDoc_children_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "last", _wrap__xmlDoc_last_get, _wrap__xmlDoc_last_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "parent", _wrap__xmlDoc_parent_get, _wrap__xmlDoc_parent_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "next", _wrap__xmlDoc_next_get, _wrap__xmlDoc_next_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "prev", _wrap__xmlDoc_prev_get, _wrap__xmlDoc_prev_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "doc", _wrap__xmlDoc_doc_get, _wrap__xmlDoc_doc_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "compression", _wrap__xmlDoc_compression_get, _wrap__xmlDoc_compression_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "standalone", _wrap__xmlDoc_standalone_get, _wrap__xmlDoc_standalone_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "intSubset", _wrap__xmlDoc_intSubset_get, _wrap__xmlDoc_intSubset_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "extSubset", _wrap__xmlDoc_extSubset_get, _wrap__xmlDoc_extSubset_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "oldNs", _wrap__xmlDoc_oldNs_get, _wrap__xmlDoc_oldNs_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "version", _wrap__xmlDoc_version_get, _wrap__xmlDoc_version_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "encoding", _wrap__xmlDoc_encoding_get, _wrap__xmlDoc_encoding_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "ids", _wrap__xmlDoc_ids_get, _wrap__xmlDoc_ids_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "refs", _wrap__xmlDoc_refs_get, _wrap__xmlDoc_refs_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "URL", _wrap__xmlDoc_URL_get, _wrap__xmlDoc_URL_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "charset", _wrap__xmlDoc_charset_get, _wrap__xmlDoc_charset_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "dict", _wrap__xmlDoc_dict_get, _wrap__xmlDoc_dict_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "psvi", _wrap__xmlDoc_psvi_get, _wrap__xmlDoc_psvi_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "parseFlags", _wrap__xmlDoc_parseFlags_get, _wrap__xmlDoc_parseFlags_set);
SWIGV8_AddMemberVariable(_exports__xmlDoc_class, "properties", _wrap__xmlDoc_properties_get, _wrap__xmlDoc_properties_set);
SWIGV8_AddMemberVariable(_exports__xmlDOMWrapCtxt_class, "_private", _wrap__xmlDOMWrapCtxt__private_get, _wrap__xmlDOMWrapCtxt__private_set);
SWIGV8_AddMemberVariable(_exports__xmlDOMWrapCtxt_class, "type", _wrap__xmlDOMWrapCtxt_type_get, _wrap__xmlDOMWrapCtxt_type_set);
SWIGV8_AddMemberVariable(_exports__xmlDOMWrapCtxt_class, "namespaceMap", _wrap__xmlDOMWrapCtxt_namespaceMap_get, _wrap__xmlDOMWrapCtxt_namespaceMap_set);
SWIGV8_AddMemberVariable(_exports__xmlDOMWrapCtxt_class, "getNsForNodeFunc", _wrap__xmlDOMWrapCtxt_getNsForNodeFunc_get, _wrap__xmlDOMWrapCtxt_getNsForNodeFunc_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NONE", exports_XML_ERR_NONE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_WARNING", exports_XML_ERR_WARNING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ERROR", exports_XML_ERR_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_FATAL", exports_XML_ERR_FATAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_NONE", exports_XML_FROM_NONE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_PARSER", exports_XML_FROM_PARSER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_TREE", exports_XML_FROM_TREE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_NAMESPACE", exports_XML_FROM_NAMESPACE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_DTD", exports_XML_FROM_DTD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_HTML", exports_XML_FROM_HTML_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_MEMORY", exports_XML_FROM_MEMORY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_OUTPUT", exports_XML_FROM_OUTPUT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_IO", exports_XML_FROM_IO_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_FTP", exports_XML_FROM_FTP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_HTTP", exports_XML_FROM_HTTP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_XINCLUDE", exports_XML_FROM_XINCLUDE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_XPATH", exports_XML_FROM_XPATH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_XPOINTER", exports_XML_FROM_XPOINTER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_REGEXP", exports_XML_FROM_REGEXP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_DATATYPE", exports_XML_FROM_DATATYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_SCHEMASP", exports_XML_FROM_SCHEMASP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_SCHEMASV", exports_XML_FROM_SCHEMASV_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_RELAXNGP", exports_XML_FROM_RELAXNGP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_RELAXNGV", exports_XML_FROM_RELAXNGV_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_CATALOG", exports_XML_FROM_CATALOG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_C14N", exports_XML_FROM_C14N_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_XSLT", exports_XML_FROM_XSLT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_VALID", exports_XML_FROM_VALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_CHECK", exports_XML_FROM_CHECK_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_WRITER", exports_XML_FROM_WRITER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_MODULE", exports_XML_FROM_MODULE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_I18N", exports_XML_FROM_I18N_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_SCHEMATRONV", exports_XML_FROM_SCHEMATRONV_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_BUFFER", exports_XML_FROM_BUFFER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_URI", exports_XML_FROM_URI_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlError_class, "domain", _wrap__xmlError_domain_get, _wrap__xmlError_domain_set);
SWIGV8_AddMemberVariable(_exports__xmlError_class, "code", _wrap__xmlError_code_get, _wrap__xmlError_code_set);
SWIGV8_AddMemberVariable(_exports__xmlError_class, "message", _wrap__xmlError_message_get, _wrap__xmlError_message_set);
SWIGV8_AddMemberVariable(_exports__xmlError_class, "level", _wrap__xmlError_level_get, _wrap__xmlError_level_set);
SWIGV8_AddMemberVariable(_exports__xmlError_class, "file", _wrap__xmlError_file_get, _wrap__xmlError_file_set);
SWIGV8_AddMemberVariable(_exports__xmlError_class, "line", _wrap__xmlError_line_get, _wrap__xmlError_line_set);
SWIGV8_AddMemberVariable(_exports__xmlError_class, "str1", _wrap__xmlError_str1_get, _wrap__xmlError_str1_set);
SWIGV8_AddMemberVariable(_exports__xmlError_class, "str2", _wrap__xmlError_str2_get, _wrap__xmlError_str2_set);
SWIGV8_AddMemberVariable(_exports__xmlError_class, "str3", _wrap__xmlError_str3_get, _wrap__xmlError_str3_set);
SWIGV8_AddMemberVariable(_exports__xmlError_class, "int1", _wrap__xmlError_int1_get, _wrap__xmlError_int1_set);
SWIGV8_AddMemberVariable(_exports__xmlError_class, "int2", _wrap__xmlError_int2_get, _wrap__xmlError_int2_set);
SWIGV8_AddMemberVariable(_exports__xmlError_class, "ctxt", _wrap__xmlError_ctxt_get, _wrap__xmlError_ctxt_set);
SWIGV8_AddMemberVariable(_exports__xmlError_class, "node", _wrap__xmlError_node_get, _wrap__xmlError_node_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_OK", exports_XML_ERR_OK_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_INTERNAL_ERROR", exports_XML_ERR_INTERNAL_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NO_MEMORY", exports_XML_ERR_NO_MEMORY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_DOCUMENT_START", exports_XML_ERR_DOCUMENT_START_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_DOCUMENT_EMPTY", exports_XML_ERR_DOCUMENT_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_DOCUMENT_END", exports_XML_ERR_DOCUMENT_END_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_INVALID_HEX_CHARREF", exports_XML_ERR_INVALID_HEX_CHARREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_INVALID_DEC_CHARREF", exports_XML_ERR_INVALID_DEC_CHARREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_INVALID_CHARREF", exports_XML_ERR_INVALID_CHARREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_INVALID_CHAR", exports_XML_ERR_INVALID_CHAR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CHARREF_AT_EOF", exports_XML_ERR_CHARREF_AT_EOF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CHARREF_IN_PROLOG", exports_XML_ERR_CHARREF_IN_PROLOG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CHARREF_IN_EPILOG", exports_XML_ERR_CHARREF_IN_EPILOG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CHARREF_IN_DTD", exports_XML_ERR_CHARREF_IN_DTD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITYREF_AT_EOF", exports_XML_ERR_ENTITYREF_AT_EOF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITYREF_IN_PROLOG", exports_XML_ERR_ENTITYREF_IN_PROLOG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITYREF_IN_EPILOG", exports_XML_ERR_ENTITYREF_IN_EPILOG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITYREF_IN_DTD", exports_XML_ERR_ENTITYREF_IN_DTD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PEREF_AT_EOF", exports_XML_ERR_PEREF_AT_EOF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PEREF_IN_PROLOG", exports_XML_ERR_PEREF_IN_PROLOG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PEREF_IN_EPILOG", exports_XML_ERR_PEREF_IN_EPILOG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PEREF_IN_INT_SUBSET", exports_XML_ERR_PEREF_IN_INT_SUBSET_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITYREF_NO_NAME", exports_XML_ERR_ENTITYREF_NO_NAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITYREF_SEMICOL_MISSING", exports_XML_ERR_ENTITYREF_SEMICOL_MISSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PEREF_NO_NAME", exports_XML_ERR_PEREF_NO_NAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PEREF_SEMICOL_MISSING", exports_XML_ERR_PEREF_SEMICOL_MISSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_UNDECLARED_ENTITY", exports_XML_ERR_UNDECLARED_ENTITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_UNDECLARED_ENTITY", exports_XML_WAR_UNDECLARED_ENTITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_UNPARSED_ENTITY", exports_XML_ERR_UNPARSED_ENTITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_IS_EXTERNAL", exports_XML_ERR_ENTITY_IS_EXTERNAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_IS_PARAMETER", exports_XML_ERR_ENTITY_IS_PARAMETER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_UNKNOWN_ENCODING", exports_XML_ERR_UNKNOWN_ENCODING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_UNSUPPORTED_ENCODING", exports_XML_ERR_UNSUPPORTED_ENCODING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_STRING_NOT_STARTED", exports_XML_ERR_STRING_NOT_STARTED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_STRING_NOT_CLOSED", exports_XML_ERR_STRING_NOT_CLOSED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NS_DECL_ERROR", exports_XML_ERR_NS_DECL_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_NOT_STARTED", exports_XML_ERR_ENTITY_NOT_STARTED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_NOT_FINISHED", exports_XML_ERR_ENTITY_NOT_FINISHED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_LT_IN_ATTRIBUTE", exports_XML_ERR_LT_IN_ATTRIBUTE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ATTRIBUTE_NOT_STARTED", exports_XML_ERR_ATTRIBUTE_NOT_STARTED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ATTRIBUTE_NOT_FINISHED", exports_XML_ERR_ATTRIBUTE_NOT_FINISHED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ATTRIBUTE_WITHOUT_VALUE", exports_XML_ERR_ATTRIBUTE_WITHOUT_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ATTRIBUTE_REDEFINED", exports_XML_ERR_ATTRIBUTE_REDEFINED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_LITERAL_NOT_STARTED", exports_XML_ERR_LITERAL_NOT_STARTED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_LITERAL_NOT_FINISHED", exports_XML_ERR_LITERAL_NOT_FINISHED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_COMMENT_NOT_FINISHED", exports_XML_ERR_COMMENT_NOT_FINISHED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PI_NOT_STARTED", exports_XML_ERR_PI_NOT_STARTED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PI_NOT_FINISHED", exports_XML_ERR_PI_NOT_FINISHED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NOTATION_NOT_STARTED", exports_XML_ERR_NOTATION_NOT_STARTED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NOTATION_NOT_FINISHED", exports_XML_ERR_NOTATION_NOT_FINISHED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ATTLIST_NOT_STARTED", exports_XML_ERR_ATTLIST_NOT_STARTED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ATTLIST_NOT_FINISHED", exports_XML_ERR_ATTLIST_NOT_FINISHED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_MIXED_NOT_STARTED", exports_XML_ERR_MIXED_NOT_STARTED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_MIXED_NOT_FINISHED", exports_XML_ERR_MIXED_NOT_FINISHED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ELEMCONTENT_NOT_STARTED", exports_XML_ERR_ELEMCONTENT_NOT_STARTED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ELEMCONTENT_NOT_FINISHED", exports_XML_ERR_ELEMCONTENT_NOT_FINISHED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_XMLDECL_NOT_STARTED", exports_XML_ERR_XMLDECL_NOT_STARTED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_XMLDECL_NOT_FINISHED", exports_XML_ERR_XMLDECL_NOT_FINISHED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CONDSEC_NOT_STARTED", exports_XML_ERR_CONDSEC_NOT_STARTED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CONDSEC_NOT_FINISHED", exports_XML_ERR_CONDSEC_NOT_FINISHED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_EXT_SUBSET_NOT_FINISHED", exports_XML_ERR_EXT_SUBSET_NOT_FINISHED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_DOCTYPE_NOT_FINISHED", exports_XML_ERR_DOCTYPE_NOT_FINISHED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_MISPLACED_CDATA_END", exports_XML_ERR_MISPLACED_CDATA_END_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CDATA_NOT_FINISHED", exports_XML_ERR_CDATA_NOT_FINISHED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_RESERVED_XML_NAME", exports_XML_ERR_RESERVED_XML_NAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_SPACE_REQUIRED", exports_XML_ERR_SPACE_REQUIRED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_SEPARATOR_REQUIRED", exports_XML_ERR_SEPARATOR_REQUIRED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NMTOKEN_REQUIRED", exports_XML_ERR_NMTOKEN_REQUIRED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NAME_REQUIRED", exports_XML_ERR_NAME_REQUIRED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PCDATA_REQUIRED", exports_XML_ERR_PCDATA_REQUIRED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_URI_REQUIRED", exports_XML_ERR_URI_REQUIRED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PUBID_REQUIRED", exports_XML_ERR_PUBID_REQUIRED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_LT_REQUIRED", exports_XML_ERR_LT_REQUIRED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_GT_REQUIRED", exports_XML_ERR_GT_REQUIRED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_LTSLASH_REQUIRED", exports_XML_ERR_LTSLASH_REQUIRED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_EQUAL_REQUIRED", exports_XML_ERR_EQUAL_REQUIRED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_TAG_NAME_MISMATCH", exports_XML_ERR_TAG_NAME_MISMATCH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_TAG_NOT_FINISHED", exports_XML_ERR_TAG_NOT_FINISHED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_STANDALONE_VALUE", exports_XML_ERR_STANDALONE_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENCODING_NAME", exports_XML_ERR_ENCODING_NAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_HYPHEN_IN_COMMENT", exports_XML_ERR_HYPHEN_IN_COMMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_INVALID_ENCODING", exports_XML_ERR_INVALID_ENCODING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_EXT_ENTITY_STANDALONE", exports_XML_ERR_EXT_ENTITY_STANDALONE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CONDSEC_INVALID", exports_XML_ERR_CONDSEC_INVALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_VALUE_REQUIRED", exports_XML_ERR_VALUE_REQUIRED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NOT_WELL_BALANCED", exports_XML_ERR_NOT_WELL_BALANCED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_EXTRA_CONTENT", exports_XML_ERR_EXTRA_CONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_CHAR_ERROR", exports_XML_ERR_ENTITY_CHAR_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_PE_INTERNAL", exports_XML_ERR_ENTITY_PE_INTERNAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_LOOP", exports_XML_ERR_ENTITY_LOOP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_BOUNDARY", exports_XML_ERR_ENTITY_BOUNDARY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_INVALID_URI", exports_XML_ERR_INVALID_URI_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_URI_FRAGMENT", exports_XML_ERR_URI_FRAGMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_CATALOG_PI", exports_XML_WAR_CATALOG_PI_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NO_DTD", exports_XML_ERR_NO_DTD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CONDSEC_INVALID_KEYWORD", exports_XML_ERR_CONDSEC_INVALID_KEYWORD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_VERSION_MISSING", exports_XML_ERR_VERSION_MISSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_UNKNOWN_VERSION", exports_XML_WAR_UNKNOWN_VERSION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_LANG_VALUE", exports_XML_WAR_LANG_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_NS_URI", exports_XML_WAR_NS_URI_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_NS_URI_RELATIVE", exports_XML_WAR_NS_URI_RELATIVE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_MISSING_ENCODING", exports_XML_ERR_MISSING_ENCODING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_SPACE_VALUE", exports_XML_WAR_SPACE_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NOT_STANDALONE", exports_XML_ERR_NOT_STANDALONE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_PROCESSING", exports_XML_ERR_ENTITY_PROCESSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NOTATION_PROCESSING", exports_XML_ERR_NOTATION_PROCESSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_NS_COLUMN", exports_XML_WAR_NS_COLUMN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_ENTITY_REDEFINED", exports_XML_WAR_ENTITY_REDEFINED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_UNKNOWN_VERSION", exports_XML_ERR_UNKNOWN_VERSION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_VERSION_MISMATCH", exports_XML_ERR_VERSION_MISMATCH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NAME_TOO_LONG", exports_XML_ERR_NAME_TOO_LONG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_USER_STOP", exports_XML_ERR_USER_STOP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_COMMENT_ABRUPTLY_ENDED", exports_XML_ERR_COMMENT_ABRUPTLY_ENDED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_ENCODING_MISMATCH", exports_XML_WAR_ENCODING_MISMATCH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_RESOURCE_LIMIT", exports_XML_ERR_RESOURCE_LIMIT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ARGUMENT", exports_XML_ERR_ARGUMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_SYSTEM", exports_XML_ERR_SYSTEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_REDECL_PREDEF_ENTITY", exports_XML_ERR_REDECL_PREDEF_ENTITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_INT_SUBSET_NOT_FINISHED", exports_XML_ERR_INT_SUBSET_NOT_FINISHED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_NS_ERR_XML_NAMESPACE", exports_XML_NS_ERR_XML_NAMESPACE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_NS_ERR_UNDEFINED_NAMESPACE", exports_XML_NS_ERR_UNDEFINED_NAMESPACE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_NS_ERR_QNAME", exports_XML_NS_ERR_QNAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_NS_ERR_ATTRIBUTE_REDEFINED", exports_XML_NS_ERR_ATTRIBUTE_REDEFINED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_NS_ERR_EMPTY", exports_XML_NS_ERR_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_NS_ERR_COLON", exports_XML_NS_ERR_COLON_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ATTRIBUTE_DEFAULT", exports_XML_DTD_ATTRIBUTE_DEFAULT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ATTRIBUTE_REDEFINED", exports_XML_DTD_ATTRIBUTE_REDEFINED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ATTRIBUTE_VALUE", exports_XML_DTD_ATTRIBUTE_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_CONTENT_ERROR", exports_XML_DTD_CONTENT_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_CONTENT_MODEL", exports_XML_DTD_CONTENT_MODEL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_CONTENT_NOT_DETERMINIST", exports_XML_DTD_CONTENT_NOT_DETERMINIST_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_DIFFERENT_PREFIX", exports_XML_DTD_DIFFERENT_PREFIX_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ELEM_DEFAULT_NAMESPACE", exports_XML_DTD_ELEM_DEFAULT_NAMESPACE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ELEM_NAMESPACE", exports_XML_DTD_ELEM_NAMESPACE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ELEM_REDEFINED", exports_XML_DTD_ELEM_REDEFINED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_EMPTY_NOTATION", exports_XML_DTD_EMPTY_NOTATION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ENTITY_TYPE", exports_XML_DTD_ENTITY_TYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ID_FIXED", exports_XML_DTD_ID_FIXED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ID_REDEFINED", exports_XML_DTD_ID_REDEFINED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ID_SUBSET", exports_XML_DTD_ID_SUBSET_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_INVALID_CHILD", exports_XML_DTD_INVALID_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_INVALID_DEFAULT", exports_XML_DTD_INVALID_DEFAULT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_LOAD_ERROR", exports_XML_DTD_LOAD_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_MISSING_ATTRIBUTE", exports_XML_DTD_MISSING_ATTRIBUTE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_MIXED_CORRUPT", exports_XML_DTD_MIXED_CORRUPT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_MULTIPLE_ID", exports_XML_DTD_MULTIPLE_ID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NO_DOC", exports_XML_DTD_NO_DOC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NO_DTD", exports_XML_DTD_NO_DTD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NO_ELEM_NAME", exports_XML_DTD_NO_ELEM_NAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NO_PREFIX", exports_XML_DTD_NO_PREFIX_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NO_ROOT", exports_XML_DTD_NO_ROOT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NOTATION_REDEFINED", exports_XML_DTD_NOTATION_REDEFINED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NOTATION_VALUE", exports_XML_DTD_NOTATION_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NOT_EMPTY", exports_XML_DTD_NOT_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NOT_PCDATA", exports_XML_DTD_NOT_PCDATA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NOT_STANDALONE", exports_XML_DTD_NOT_STANDALONE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ROOT_NAME", exports_XML_DTD_ROOT_NAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_STANDALONE_WHITE_SPACE", exports_XML_DTD_STANDALONE_WHITE_SPACE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_UNKNOWN_ATTRIBUTE", exports_XML_DTD_UNKNOWN_ATTRIBUTE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_UNKNOWN_ELEM", exports_XML_DTD_UNKNOWN_ELEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_UNKNOWN_ENTITY", exports_XML_DTD_UNKNOWN_ENTITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_UNKNOWN_ID", exports_XML_DTD_UNKNOWN_ID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_UNKNOWN_NOTATION", exports_XML_DTD_UNKNOWN_NOTATION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_STANDALONE_DEFAULTED", exports_XML_DTD_STANDALONE_DEFAULTED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_XMLID_VALUE", exports_XML_DTD_XMLID_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_XMLID_TYPE", exports_XML_DTD_XMLID_TYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_DUP_TOKEN", exports_XML_DTD_DUP_TOKEN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_HTML_STRUCURE_ERROR", exports_XML_HTML_STRUCURE_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_HTML_UNKNOWN_TAG", exports_XML_HTML_UNKNOWN_TAG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_HTML_INCORRECTLY_OPENED_COMMENT", exports_XML_HTML_INCORRECTLY_OPENED_COMMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ANYNAME_ATTR_ANCESTOR", exports_XML_RNGP_ANYNAME_ATTR_ANCESTOR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ATTR_CONFLICT", exports_XML_RNGP_ATTR_CONFLICT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ATTRIBUTE_CHILDREN", exports_XML_RNGP_ATTRIBUTE_CHILDREN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ATTRIBUTE_CONTENT", exports_XML_RNGP_ATTRIBUTE_CONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ATTRIBUTE_EMPTY", exports_XML_RNGP_ATTRIBUTE_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ATTRIBUTE_NOOP", exports_XML_RNGP_ATTRIBUTE_NOOP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_CHOICE_CONTENT", exports_XML_RNGP_CHOICE_CONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_CHOICE_EMPTY", exports_XML_RNGP_CHOICE_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_CREATE_FAILURE", exports_XML_RNGP_CREATE_FAILURE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_DATA_CONTENT", exports_XML_RNGP_DATA_CONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_DEF_CHOICE_AND_INTERLEAVE", exports_XML_RNGP_DEF_CHOICE_AND_INTERLEAVE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_DEFINE_CREATE_FAILED", exports_XML_RNGP_DEFINE_CREATE_FAILED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_DEFINE_EMPTY", exports_XML_RNGP_DEFINE_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_DEFINE_MISSING", exports_XML_RNGP_DEFINE_MISSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_DEFINE_NAME_MISSING", exports_XML_RNGP_DEFINE_NAME_MISSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ELEM_CONTENT_EMPTY", exports_XML_RNGP_ELEM_CONTENT_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ELEM_CONTENT_ERROR", exports_XML_RNGP_ELEM_CONTENT_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ELEMENT_EMPTY", exports_XML_RNGP_ELEMENT_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ELEMENT_CONTENT", exports_XML_RNGP_ELEMENT_CONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ELEMENT_NAME", exports_XML_RNGP_ELEMENT_NAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ELEMENT_NO_CONTENT", exports_XML_RNGP_ELEMENT_NO_CONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ELEM_TEXT_CONFLICT", exports_XML_RNGP_ELEM_TEXT_CONFLICT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EMPTY", exports_XML_RNGP_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EMPTY_CONSTRUCT", exports_XML_RNGP_EMPTY_CONSTRUCT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EMPTY_CONTENT", exports_XML_RNGP_EMPTY_CONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EMPTY_NOT_EMPTY", exports_XML_RNGP_EMPTY_NOT_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ERROR_TYPE_LIB", exports_XML_RNGP_ERROR_TYPE_LIB_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EXCEPT_EMPTY", exports_XML_RNGP_EXCEPT_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EXCEPT_MISSING", exports_XML_RNGP_EXCEPT_MISSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EXCEPT_MULTIPLE", exports_XML_RNGP_EXCEPT_MULTIPLE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EXCEPT_NO_CONTENT", exports_XML_RNGP_EXCEPT_NO_CONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EXTERNALREF_EMTPY", exports_XML_RNGP_EXTERNALREF_EMTPY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EXTERNAL_REF_FAILURE", exports_XML_RNGP_EXTERNAL_REF_FAILURE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EXTERNALREF_RECURSE", exports_XML_RNGP_EXTERNALREF_RECURSE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_FORBIDDEN_ATTRIBUTE", exports_XML_RNGP_FORBIDDEN_ATTRIBUTE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_FOREIGN_ELEMENT", exports_XML_RNGP_FOREIGN_ELEMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_GRAMMAR_CONTENT", exports_XML_RNGP_GRAMMAR_CONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_GRAMMAR_EMPTY", exports_XML_RNGP_GRAMMAR_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_GRAMMAR_MISSING", exports_XML_RNGP_GRAMMAR_MISSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_GRAMMAR_NO_START", exports_XML_RNGP_GRAMMAR_NO_START_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_GROUP_ATTR_CONFLICT", exports_XML_RNGP_GROUP_ATTR_CONFLICT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_HREF_ERROR", exports_XML_RNGP_HREF_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INCLUDE_EMPTY", exports_XML_RNGP_INCLUDE_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INCLUDE_FAILURE", exports_XML_RNGP_INCLUDE_FAILURE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INCLUDE_RECURSE", exports_XML_RNGP_INCLUDE_RECURSE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INTERLEAVE_ADD", exports_XML_RNGP_INTERLEAVE_ADD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INTERLEAVE_CREATE_FAILED", exports_XML_RNGP_INTERLEAVE_CREATE_FAILED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INTERLEAVE_EMPTY", exports_XML_RNGP_INTERLEAVE_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INTERLEAVE_NO_CONTENT", exports_XML_RNGP_INTERLEAVE_NO_CONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INVALID_DEFINE_NAME", exports_XML_RNGP_INVALID_DEFINE_NAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INVALID_URI", exports_XML_RNGP_INVALID_URI_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INVALID_VALUE", exports_XML_RNGP_INVALID_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_MISSING_HREF", exports_XML_RNGP_MISSING_HREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_NAME_MISSING", exports_XML_RNGP_NAME_MISSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_NEED_COMBINE", exports_XML_RNGP_NEED_COMBINE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_NOTALLOWED_NOT_EMPTY", exports_XML_RNGP_NOTALLOWED_NOT_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_NSNAME_ATTR_ANCESTOR", exports_XML_RNGP_NSNAME_ATTR_ANCESTOR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_NSNAME_NO_NS", exports_XML_RNGP_NSNAME_NO_NS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PARAM_FORBIDDEN", exports_XML_RNGP_PARAM_FORBIDDEN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PARAM_NAME_MISSING", exports_XML_RNGP_PARAM_NAME_MISSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PARENTREF_CREATE_FAILED", exports_XML_RNGP_PARENTREF_CREATE_FAILED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PARENTREF_NAME_INVALID", exports_XML_RNGP_PARENTREF_NAME_INVALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PARENTREF_NO_NAME", exports_XML_RNGP_PARENTREF_NO_NAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PARENTREF_NO_PARENT", exports_XML_RNGP_PARENTREF_NO_PARENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PARENTREF_NOT_EMPTY", exports_XML_RNGP_PARENTREF_NOT_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PARSE_ERROR", exports_XML_RNGP_PARSE_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME", exports_XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_ATTR_ATTR", exports_XML_RNGP_PAT_ATTR_ATTR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_ATTR_ELEM", exports_XML_RNGP_PAT_ATTR_ELEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_ATTR", exports_XML_RNGP_PAT_DATA_EXCEPT_ATTR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_ELEM", exports_XML_RNGP_PAT_DATA_EXCEPT_ELEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_EMPTY", exports_XML_RNGP_PAT_DATA_EXCEPT_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_GROUP", exports_XML_RNGP_PAT_DATA_EXCEPT_GROUP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE", exports_XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_LIST", exports_XML_RNGP_PAT_DATA_EXCEPT_LIST_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_ONEMORE", exports_XML_RNGP_PAT_DATA_EXCEPT_ONEMORE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_REF", exports_XML_RNGP_PAT_DATA_EXCEPT_REF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_TEXT", exports_XML_RNGP_PAT_DATA_EXCEPT_TEXT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_LIST_ATTR", exports_XML_RNGP_PAT_LIST_ATTR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_LIST_ELEM", exports_XML_RNGP_PAT_LIST_ELEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_LIST_INTERLEAVE", exports_XML_RNGP_PAT_LIST_INTERLEAVE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_LIST_LIST", exports_XML_RNGP_PAT_LIST_LIST_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_LIST_REF", exports_XML_RNGP_PAT_LIST_REF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_LIST_TEXT", exports_XML_RNGP_PAT_LIST_TEXT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME", exports_XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME", exports_XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_ONEMORE_GROUP_ATTR", exports_XML_RNGP_PAT_ONEMORE_GROUP_ATTR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR", exports_XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_ATTR", exports_XML_RNGP_PAT_START_ATTR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_DATA", exports_XML_RNGP_PAT_START_DATA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_EMPTY", exports_XML_RNGP_PAT_START_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_GROUP", exports_XML_RNGP_PAT_START_GROUP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_INTERLEAVE", exports_XML_RNGP_PAT_START_INTERLEAVE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_LIST", exports_XML_RNGP_PAT_START_LIST_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_ONEMORE", exports_XML_RNGP_PAT_START_ONEMORE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_TEXT", exports_XML_RNGP_PAT_START_TEXT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_VALUE", exports_XML_RNGP_PAT_START_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PREFIX_UNDEFINED", exports_XML_RNGP_PREFIX_UNDEFINED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_REF_CREATE_FAILED", exports_XML_RNGP_REF_CREATE_FAILED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_REF_CYCLE", exports_XML_RNGP_REF_CYCLE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_REF_NAME_INVALID", exports_XML_RNGP_REF_NAME_INVALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_REF_NO_DEF", exports_XML_RNGP_REF_NO_DEF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_REF_NO_NAME", exports_XML_RNGP_REF_NO_NAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_REF_NOT_EMPTY", exports_XML_RNGP_REF_NOT_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_START_CHOICE_AND_INTERLEAVE", exports_XML_RNGP_START_CHOICE_AND_INTERLEAVE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_START_CONTENT", exports_XML_RNGP_START_CONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_START_EMPTY", exports_XML_RNGP_START_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_START_MISSING", exports_XML_RNGP_START_MISSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_TEXT_EXPECTED", exports_XML_RNGP_TEXT_EXPECTED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_TEXT_HAS_CHILD", exports_XML_RNGP_TEXT_HAS_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_TYPE_MISSING", exports_XML_RNGP_TYPE_MISSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_TYPE_NOT_FOUND", exports_XML_RNGP_TYPE_NOT_FOUND_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_TYPE_VALUE", exports_XML_RNGP_TYPE_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_UNKNOWN_ATTRIBUTE", exports_XML_RNGP_UNKNOWN_ATTRIBUTE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_UNKNOWN_COMBINE", exports_XML_RNGP_UNKNOWN_COMBINE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_UNKNOWN_CONSTRUCT", exports_XML_RNGP_UNKNOWN_CONSTRUCT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_UNKNOWN_TYPE_LIB", exports_XML_RNGP_UNKNOWN_TYPE_LIB_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_URI_FRAGMENT", exports_XML_RNGP_URI_FRAGMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_URI_NOT_ABSOLUTE", exports_XML_RNGP_URI_NOT_ABSOLUTE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_VALUE_EMPTY", exports_XML_RNGP_VALUE_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_VALUE_NO_CONTENT", exports_XML_RNGP_VALUE_NO_CONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_XMLNS_NAME", exports_XML_RNGP_XMLNS_NAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_XML_NS", exports_XML_RNGP_XML_NS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_EXPRESSION_OK", exports_XML_XPATH_EXPRESSION_OK_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_NUMBER_ERROR", exports_XML_XPATH_NUMBER_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_UNFINISHED_LITERAL_ERROR", exports_XML_XPATH_UNFINISHED_LITERAL_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_START_LITERAL_ERROR", exports_XML_XPATH_START_LITERAL_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_VARIABLE_REF_ERROR", exports_XML_XPATH_VARIABLE_REF_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_UNDEF_VARIABLE_ERROR", exports_XML_XPATH_UNDEF_VARIABLE_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_INVALID_PREDICATE_ERROR", exports_XML_XPATH_INVALID_PREDICATE_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_EXPR_ERROR", exports_XML_XPATH_EXPR_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_UNCLOSED_ERROR", exports_XML_XPATH_UNCLOSED_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_UNKNOWN_FUNC_ERROR", exports_XML_XPATH_UNKNOWN_FUNC_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_INVALID_OPERAND", exports_XML_XPATH_INVALID_OPERAND_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_INVALID_TYPE", exports_XML_XPATH_INVALID_TYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_INVALID_ARITY", exports_XML_XPATH_INVALID_ARITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_INVALID_CTXT_SIZE", exports_XML_XPATH_INVALID_CTXT_SIZE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_INVALID_CTXT_POSITION", exports_XML_XPATH_INVALID_CTXT_POSITION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_MEMORY_ERROR", exports_XML_XPATH_MEMORY_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPTR_SYNTAX_ERROR", exports_XML_XPTR_SYNTAX_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPTR_RESOURCE_ERROR", exports_XML_XPTR_RESOURCE_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPTR_SUB_RESOURCE_ERROR", exports_XML_XPTR_SUB_RESOURCE_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_UNDEF_PREFIX_ERROR", exports_XML_XPATH_UNDEF_PREFIX_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_ENCODING_ERROR", exports_XML_XPATH_ENCODING_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_INVALID_CHAR_ERROR", exports_XML_XPATH_INVALID_CHAR_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_TREE_INVALID_HEX", exports_XML_TREE_INVALID_HEX_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_TREE_INVALID_DEC", exports_XML_TREE_INVALID_DEC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_TREE_UNTERMINATED_ENTITY", exports_XML_TREE_UNTERMINATED_ENTITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_TREE_NOT_UTF8", exports_XML_TREE_NOT_UTF8_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_NOT_UTF8", exports_XML_SAVE_NOT_UTF8_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_CHAR_INVALID", exports_XML_SAVE_CHAR_INVALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_NO_DOCTYPE", exports_XML_SAVE_NO_DOCTYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_UNKNOWN_ENCODING", exports_XML_SAVE_UNKNOWN_ENCODING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_REGEXP_COMPILE_ERROR", exports_XML_REGEXP_COMPILE_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_UNKNOWN", exports_XML_IO_UNKNOWN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EACCES", exports_XML_IO_EACCES_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EAGAIN", exports_XML_IO_EAGAIN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EBADF", exports_XML_IO_EBADF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EBADMSG", exports_XML_IO_EBADMSG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EBUSY", exports_XML_IO_EBUSY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ECANCELED", exports_XML_IO_ECANCELED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ECHILD", exports_XML_IO_ECHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EDEADLK", exports_XML_IO_EDEADLK_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EDOM", exports_XML_IO_EDOM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EEXIST", exports_XML_IO_EEXIST_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EFAULT", exports_XML_IO_EFAULT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EFBIG", exports_XML_IO_EFBIG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EINPROGRESS", exports_XML_IO_EINPROGRESS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EINTR", exports_XML_IO_EINTR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EINVAL", exports_XML_IO_EINVAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EIO", exports_XML_IO_EIO_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EISDIR", exports_XML_IO_EISDIR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EMFILE", exports_XML_IO_EMFILE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EMLINK", exports_XML_IO_EMLINK_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EMSGSIZE", exports_XML_IO_EMSGSIZE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENAMETOOLONG", exports_XML_IO_ENAMETOOLONG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENFILE", exports_XML_IO_ENFILE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENODEV", exports_XML_IO_ENODEV_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOENT", exports_XML_IO_ENOENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOEXEC", exports_XML_IO_ENOEXEC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOLCK", exports_XML_IO_ENOLCK_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOMEM", exports_XML_IO_ENOMEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOSPC", exports_XML_IO_ENOSPC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOSYS", exports_XML_IO_ENOSYS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOTDIR", exports_XML_IO_ENOTDIR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOTEMPTY", exports_XML_IO_ENOTEMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOTSUP", exports_XML_IO_ENOTSUP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOTTY", exports_XML_IO_ENOTTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENXIO", exports_XML_IO_ENXIO_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EPERM", exports_XML_IO_EPERM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EPIPE", exports_XML_IO_EPIPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ERANGE", exports_XML_IO_ERANGE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EROFS", exports_XML_IO_EROFS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ESPIPE", exports_XML_IO_ESPIPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ESRCH", exports_XML_IO_ESRCH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ETIMEDOUT", exports_XML_IO_ETIMEDOUT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EXDEV", exports_XML_IO_EXDEV_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_NETWORK_ATTEMPT", exports_XML_IO_NETWORK_ATTEMPT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENCODER", exports_XML_IO_ENCODER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_FLUSH", exports_XML_IO_FLUSH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_WRITE", exports_XML_IO_WRITE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_NO_INPUT", exports_XML_IO_NO_INPUT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_BUFFER_FULL", exports_XML_IO_BUFFER_FULL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_LOAD_ERROR", exports_XML_IO_LOAD_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOTSOCK", exports_XML_IO_ENOTSOCK_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EISCONN", exports_XML_IO_EISCONN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ECONNREFUSED", exports_XML_IO_ECONNREFUSED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENETUNREACH", exports_XML_IO_ENETUNREACH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EADDRINUSE", exports_XML_IO_EADDRINUSE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EALREADY", exports_XML_IO_EALREADY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EAFNOSUPPORT", exports_XML_IO_EAFNOSUPPORT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_UNSUPPORTED_PROTOCOL", exports_XML_IO_UNSUPPORTED_PROTOCOL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_RECURSION", exports_XML_XINCLUDE_RECURSION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_PARSE_VALUE", exports_XML_XINCLUDE_PARSE_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_ENTITY_DEF_MISMATCH", exports_XML_XINCLUDE_ENTITY_DEF_MISMATCH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_NO_HREF", exports_XML_XINCLUDE_NO_HREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_NO_FALLBACK", exports_XML_XINCLUDE_NO_FALLBACK_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_HREF_URI", exports_XML_XINCLUDE_HREF_URI_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_TEXT_FRAGMENT", exports_XML_XINCLUDE_TEXT_FRAGMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_TEXT_DOCUMENT", exports_XML_XINCLUDE_TEXT_DOCUMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_INVALID_CHAR", exports_XML_XINCLUDE_INVALID_CHAR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_BUILD_FAILED", exports_XML_XINCLUDE_BUILD_FAILED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_UNKNOWN_ENCODING", exports_XML_XINCLUDE_UNKNOWN_ENCODING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_MULTIPLE_ROOT", exports_XML_XINCLUDE_MULTIPLE_ROOT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_XPTR_FAILED", exports_XML_XINCLUDE_XPTR_FAILED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_XPTR_RESULT", exports_XML_XINCLUDE_XPTR_RESULT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_INCLUDE_IN_INCLUDE", exports_XML_XINCLUDE_INCLUDE_IN_INCLUDE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_FALLBACKS_IN_INCLUDE", exports_XML_XINCLUDE_FALLBACKS_IN_INCLUDE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE", exports_XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_DEPRECATED_NS", exports_XML_XINCLUDE_DEPRECATED_NS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_FRAGMENT_ID", exports_XML_XINCLUDE_FRAGMENT_ID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATALOG_MISSING_ATTR", exports_XML_CATALOG_MISSING_ATTR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATALOG_ENTRY_BROKEN", exports_XML_CATALOG_ENTRY_BROKEN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATALOG_PREFER_VALUE", exports_XML_CATALOG_PREFER_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATALOG_NOT_CATALOG", exports_XML_CATALOG_NOT_CATALOG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATALOG_RECURSION", exports_XML_CATALOG_RECURSION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_PREFIX_UNDEFINED", exports_XML_SCHEMAP_PREFIX_UNDEFINED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ATTRFORMDEFAULT_VALUE", exports_XML_SCHEMAP_ATTRFORMDEFAULT_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ATTRGRP_NONAME_NOREF", exports_XML_SCHEMAP_ATTRGRP_NONAME_NOREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ATTR_NONAME_NOREF", exports_XML_SCHEMAP_ATTR_NONAME_NOREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF", exports_XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ELEMFORMDEFAULT_VALUE", exports_XML_SCHEMAP_ELEMFORMDEFAULT_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ELEM_NONAME_NOREF", exports_XML_SCHEMAP_ELEM_NONAME_NOREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_EXTENSION_NO_BASE", exports_XML_SCHEMAP_EXTENSION_NO_BASE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_FACET_NO_VALUE", exports_XML_SCHEMAP_FACET_NO_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_FAILED_BUILD_IMPORT", exports_XML_SCHEMAP_FAILED_BUILD_IMPORT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_GROUP_NONAME_NOREF", exports_XML_SCHEMAP_GROUP_NONAME_NOREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI", exports_XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_IMPORT_REDEFINE_NSNAME", exports_XML_SCHEMAP_IMPORT_REDEFINE_NSNAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI", exports_XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_BOOLEAN", exports_XML_SCHEMAP_INVALID_BOOLEAN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_ENUM", exports_XML_SCHEMAP_INVALID_ENUM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_FACET", exports_XML_SCHEMAP_INVALID_FACET_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_FACET_VALUE", exports_XML_SCHEMAP_INVALID_FACET_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_MAXOCCURS", exports_XML_SCHEMAP_INVALID_MAXOCCURS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_MINOCCURS", exports_XML_SCHEMAP_INVALID_MINOCCURS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_REF_AND_SUBTYPE", exports_XML_SCHEMAP_INVALID_REF_AND_SUBTYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_WHITE_SPACE", exports_XML_SCHEMAP_INVALID_WHITE_SPACE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NOATTR_NOREF", exports_XML_SCHEMAP_NOATTR_NOREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NOTATION_NO_NAME", exports_XML_SCHEMAP_NOTATION_NO_NAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NOTYPE_NOREF", exports_XML_SCHEMAP_NOTYPE_NOREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REF_AND_SUBTYPE", exports_XML_SCHEMAP_REF_AND_SUBTYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_RESTRICTION_NONAME_NOREF", exports_XML_SCHEMAP_RESTRICTION_NONAME_NOREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SIMPLETYPE_NONAME", exports_XML_SCHEMAP_SIMPLETYPE_NONAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_TYPE_AND_SUBTYPE", exports_XML_SCHEMAP_TYPE_AND_SUBTYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_ALL_CHILD", exports_XML_SCHEMAP_UNKNOWN_ALL_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD", exports_XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_ATTR_CHILD", exports_XML_SCHEMAP_UNKNOWN_ATTR_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD", exports_XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP", exports_XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_BASE_TYPE", exports_XML_SCHEMAP_UNKNOWN_BASE_TYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_CHOICE_CHILD", exports_XML_SCHEMAP_UNKNOWN_CHOICE_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD", exports_XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD", exports_XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_ELEM_CHILD", exports_XML_SCHEMAP_UNKNOWN_ELEM_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD", exports_XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_FACET_CHILD", exports_XML_SCHEMAP_UNKNOWN_FACET_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_FACET_TYPE", exports_XML_SCHEMAP_UNKNOWN_FACET_TYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_GROUP_CHILD", exports_XML_SCHEMAP_UNKNOWN_GROUP_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_IMPORT_CHILD", exports_XML_SCHEMAP_UNKNOWN_IMPORT_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_LIST_CHILD", exports_XML_SCHEMAP_UNKNOWN_LIST_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_NOTATION_CHILD", exports_XML_SCHEMAP_UNKNOWN_NOTATION_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD", exports_XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_REF", exports_XML_SCHEMAP_UNKNOWN_REF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD", exports_XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD", exports_XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD", exports_XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD", exports_XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD", exports_XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_TYPE", exports_XML_SCHEMAP_UNKNOWN_TYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_UNION_CHILD", exports_XML_SCHEMAP_UNKNOWN_UNION_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ELEM_DEFAULT_FIXED", exports_XML_SCHEMAP_ELEM_DEFAULT_FIXED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REGEXP_INVALID", exports_XML_SCHEMAP_REGEXP_INVALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_FAILED_LOAD", exports_XML_SCHEMAP_FAILED_LOAD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NOTHING_TO_PARSE", exports_XML_SCHEMAP_NOTHING_TO_PARSE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NOROOT", exports_XML_SCHEMAP_NOROOT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REDEFINED_GROUP", exports_XML_SCHEMAP_REDEFINED_GROUP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REDEFINED_TYPE", exports_XML_SCHEMAP_REDEFINED_TYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REDEFINED_ELEMENT", exports_XML_SCHEMAP_REDEFINED_ELEMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REDEFINED_ATTRGROUP", exports_XML_SCHEMAP_REDEFINED_ATTRGROUP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REDEFINED_ATTR", exports_XML_SCHEMAP_REDEFINED_ATTR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REDEFINED_NOTATION", exports_XML_SCHEMAP_REDEFINED_NOTATION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_FAILED_PARSE", exports_XML_SCHEMAP_FAILED_PARSE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_PREFIX", exports_XML_SCHEMAP_UNKNOWN_PREFIX_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DEF_AND_PREFIX", exports_XML_SCHEMAP_DEF_AND_PREFIX_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD", exports_XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI", exports_XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI", exports_XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NOT_SCHEMA", exports_XML_SCHEMAP_NOT_SCHEMA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_MEMBER_TYPE", exports_XML_SCHEMAP_UNKNOWN_MEMBER_TYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_ATTR_USE", exports_XML_SCHEMAP_INVALID_ATTR_USE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_RECURSIVE", exports_XML_SCHEMAP_RECURSIVE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE", exports_XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_ATTR_COMBINATION", exports_XML_SCHEMAP_INVALID_ATTR_COMBINATION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION", exports_XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD", exports_XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_ATTR_NAME", exports_XML_SCHEMAP_INVALID_ATTR_NAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REF_AND_CONTENT", exports_XML_SCHEMAP_REF_AND_CONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_CT_PROPS_CORRECT_1", exports_XML_SCHEMAP_CT_PROPS_CORRECT_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_CT_PROPS_CORRECT_2", exports_XML_SCHEMAP_CT_PROPS_CORRECT_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_CT_PROPS_CORRECT_3", exports_XML_SCHEMAP_CT_PROPS_CORRECT_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_CT_PROPS_CORRECT_4", exports_XML_SCHEMAP_CT_PROPS_CORRECT_4_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_CT_PROPS_CORRECT_5", exports_XML_SCHEMAP_CT_PROPS_CORRECT_5_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1", exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1", exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2", exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2", exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3", exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER", exports_XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE", exports_XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNION_NOT_EXPRESSIBLE", exports_XML_SCHEMAP_UNION_NOT_EXPRESSIBLE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_IMPORT_3_1", exports_XML_SCHEMAP_SRC_IMPORT_3_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_IMPORT_3_2", exports_XML_SCHEMAP_SRC_IMPORT_3_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1", exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2", exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3", exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_CT_EXTENDS_1_3", exports_XML_SCHEMAP_COS_CT_EXTENDS_1_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_NOROOT", exports_XML_SCHEMAV_NOROOT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_UNDECLAREDELEM", exports_XML_SCHEMAV_UNDECLAREDELEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_NOTTOPLEVEL", exports_XML_SCHEMAV_NOTTOPLEVEL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_MISSING", exports_XML_SCHEMAV_MISSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_WRONGELEM", exports_XML_SCHEMAV_WRONGELEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_NOTYPE", exports_XML_SCHEMAV_NOTYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_NOROLLBACK", exports_XML_SCHEMAV_NOROLLBACK_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_ISABSTRACT", exports_XML_SCHEMAV_ISABSTRACT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_NOTEMPTY", exports_XML_SCHEMAV_NOTEMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_ELEMCONT", exports_XML_SCHEMAV_ELEMCONT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_HAVEDEFAULT", exports_XML_SCHEMAV_HAVEDEFAULT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_NOTNILLABLE", exports_XML_SCHEMAV_NOTNILLABLE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_EXTRACONTENT", exports_XML_SCHEMAV_EXTRACONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_INVALIDATTR", exports_XML_SCHEMAV_INVALIDATTR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_INVALIDELEM", exports_XML_SCHEMAV_INVALIDELEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_NOTDETERMINIST", exports_XML_SCHEMAV_NOTDETERMINIST_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CONSTRUCT", exports_XML_SCHEMAV_CONSTRUCT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_INTERNAL", exports_XML_SCHEMAV_INTERNAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_NOTSIMPLE", exports_XML_SCHEMAV_NOTSIMPLE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_ATTRUNKNOWN", exports_XML_SCHEMAV_ATTRUNKNOWN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_ATTRINVALID", exports_XML_SCHEMAV_ATTRINVALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_VALUE", exports_XML_SCHEMAV_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_FACET", exports_XML_SCHEMAV_FACET_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1", exports_XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2", exports_XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3", exports_XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_TYPE_3_1_1", exports_XML_SCHEMAV_CVC_TYPE_3_1_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_TYPE_3_1_2", exports_XML_SCHEMAV_CVC_TYPE_3_1_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_FACET_VALID", exports_XML_SCHEMAV_CVC_FACET_VALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_LENGTH_VALID", exports_XML_SCHEMAV_CVC_LENGTH_VALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_MINLENGTH_VALID", exports_XML_SCHEMAV_CVC_MINLENGTH_VALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_MAXLENGTH_VALID", exports_XML_SCHEMAV_CVC_MAXLENGTH_VALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_MININCLUSIVE_VALID", exports_XML_SCHEMAV_CVC_MININCLUSIVE_VALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID", exports_XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID", exports_XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID", exports_XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_TOTALDIGITS_VALID", exports_XML_SCHEMAV_CVC_TOTALDIGITS_VALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID", exports_XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_PATTERN_VALID", exports_XML_SCHEMAV_CVC_PATTERN_VALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ENUMERATION_VALID", exports_XML_SCHEMAV_CVC_ENUMERATION_VALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1", exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2", exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3", exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4", exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_1", exports_XML_SCHEMAV_CVC_ELT_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_2", exports_XML_SCHEMAV_CVC_ELT_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_3_1", exports_XML_SCHEMAV_CVC_ELT_3_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_3_2_1", exports_XML_SCHEMAV_CVC_ELT_3_2_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_3_2_2", exports_XML_SCHEMAV_CVC_ELT_3_2_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_4_1", exports_XML_SCHEMAV_CVC_ELT_4_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_4_2", exports_XML_SCHEMAV_CVC_ELT_4_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_4_3", exports_XML_SCHEMAV_CVC_ELT_4_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_5_1_1", exports_XML_SCHEMAV_CVC_ELT_5_1_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_5_1_2", exports_XML_SCHEMAV_CVC_ELT_5_1_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_5_2_1", exports_XML_SCHEMAV_CVC_ELT_5_2_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_5_2_2_1", exports_XML_SCHEMAV_CVC_ELT_5_2_2_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_5_2_2_2_1", exports_XML_SCHEMAV_CVC_ELT_5_2_2_2_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_5_2_2_2_2", exports_XML_SCHEMAV_CVC_ELT_5_2_2_2_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_6", exports_XML_SCHEMAV_CVC_ELT_6_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_7", exports_XML_SCHEMAV_CVC_ELT_7_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ATTRIBUTE_1", exports_XML_SCHEMAV_CVC_ATTRIBUTE_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ATTRIBUTE_2", exports_XML_SCHEMAV_CVC_ATTRIBUTE_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ATTRIBUTE_3", exports_XML_SCHEMAV_CVC_ATTRIBUTE_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ATTRIBUTE_4", exports_XML_SCHEMAV_CVC_ATTRIBUTE_4_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1", exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1", exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2", exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_4", exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_4_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1", exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2", exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_ELEMENT_CONTENT", exports_XML_SCHEMAV_ELEMENT_CONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING", exports_XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_1", exports_XML_SCHEMAV_CVC_COMPLEX_TYPE_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_AU", exports_XML_SCHEMAV_CVC_AU_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_TYPE_1", exports_XML_SCHEMAV_CVC_TYPE_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_TYPE_2", exports_XML_SCHEMAV_CVC_TYPE_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_IDC", exports_XML_SCHEMAV_CVC_IDC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_WILDCARD", exports_XML_SCHEMAV_CVC_WILDCARD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_MISC", exports_XML_SCHEMAV_MISC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPTR_UNKNOWN_SCHEME", exports_XML_XPTR_UNKNOWN_SCHEME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPTR_CHILDSEQ_START", exports_XML_XPTR_CHILDSEQ_START_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPTR_EVAL_FAILED", exports_XML_XPTR_EVAL_FAILED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPTR_EXTRA_OBJECTS", exports_XML_XPTR_EXTRA_OBJECTS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_C14N_CREATE_CTXT", exports_XML_C14N_CREATE_CTXT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_C14N_REQUIRES_UTF8", exports_XML_C14N_REQUIRES_UTF8_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_C14N_CREATE_STACK", exports_XML_C14N_CREATE_STACK_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_C14N_INVALID_NODE", exports_XML_C14N_INVALID_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_C14N_UNKNOW_NODE", exports_XML_C14N_UNKNOW_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_C14N_RELATIVE_NAMESPACE", exports_XML_C14N_RELATIVE_NAMESPACE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FTP_PASV_ANSWER", exports_XML_FTP_PASV_ANSWER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FTP_EPSV_ANSWER", exports_XML_FTP_EPSV_ANSWER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FTP_ACCNT", exports_XML_FTP_ACCNT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FTP_URL_SYNTAX", exports_XML_FTP_URL_SYNTAX_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_HTTP_URL_SYNTAX", exports_XML_HTTP_URL_SYNTAX_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_HTTP_USE_IP", exports_XML_HTTP_USE_IP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_HTTP_UNKNOWN_HOST", exports_XML_HTTP_UNKNOWN_HOST_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_SIMPLE_TYPE_1", exports_XML_SCHEMAP_SRC_SIMPLE_TYPE_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_SIMPLE_TYPE_2", exports_XML_SCHEMAP_SRC_SIMPLE_TYPE_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_SIMPLE_TYPE_3", exports_XML_SCHEMAP_SRC_SIMPLE_TYPE_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_SIMPLE_TYPE_4", exports_XML_SCHEMAP_SRC_SIMPLE_TYPE_4_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_RESOLVE", exports_XML_SCHEMAP_SRC_RESOLVE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE", exports_XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE", exports_XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES", exports_XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ST_PROPS_CORRECT_1", exports_XML_SCHEMAP_ST_PROPS_CORRECT_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ST_PROPS_CORRECT_2", exports_XML_SCHEMAP_ST_PROPS_CORRECT_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ST_PROPS_CORRECT_3", exports_XML_SCHEMAP_ST_PROPS_CORRECT_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_1_1", exports_XML_SCHEMAP_COS_ST_RESTRICTS_1_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_1_2", exports_XML_SCHEMAP_COS_ST_RESTRICTS_1_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1", exports_XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2", exports_XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_2_1", exports_XML_SCHEMAP_COS_ST_RESTRICTS_2_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1", exports_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2", exports_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1", exports_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2", exports_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3", exports_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4", exports_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5", exports_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_3_1", exports_XML_SCHEMAP_COS_ST_RESTRICTS_3_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1", exports_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2", exports_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2", exports_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1", exports_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3", exports_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4", exports_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5", exports_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_DERIVED_OK_2_1", exports_XML_SCHEMAP_COS_ST_DERIVED_OK_2_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_DERIVED_OK_2_2", exports_XML_SCHEMAP_COS_ST_DERIVED_OK_2_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED", exports_XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_S4S_ELEM_MISSING", exports_XML_SCHEMAP_S4S_ELEM_MISSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED", exports_XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_S4S_ATTR_MISSING", exports_XML_SCHEMAP_S4S_ATTR_MISSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_S4S_ATTR_INVALID_VALUE", exports_XML_SCHEMAP_S4S_ATTR_INVALID_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ELEMENT_1", exports_XML_SCHEMAP_SRC_ELEMENT_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ELEMENT_2_1", exports_XML_SCHEMAP_SRC_ELEMENT_2_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ELEMENT_2_2", exports_XML_SCHEMAP_SRC_ELEMENT_2_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ELEMENT_3", exports_XML_SCHEMAP_SRC_ELEMENT_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_P_PROPS_CORRECT_1", exports_XML_SCHEMAP_P_PROPS_CORRECT_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_P_PROPS_CORRECT_2_1", exports_XML_SCHEMAP_P_PROPS_CORRECT_2_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_P_PROPS_CORRECT_2_2", exports_XML_SCHEMAP_P_PROPS_CORRECT_2_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_E_PROPS_CORRECT_2", exports_XML_SCHEMAP_E_PROPS_CORRECT_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_E_PROPS_CORRECT_3", exports_XML_SCHEMAP_E_PROPS_CORRECT_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_E_PROPS_CORRECT_4", exports_XML_SCHEMAP_E_PROPS_CORRECT_4_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_E_PROPS_CORRECT_5", exports_XML_SCHEMAP_E_PROPS_CORRECT_5_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_E_PROPS_CORRECT_6", exports_XML_SCHEMAP_E_PROPS_CORRECT_6_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_INCLUDE", exports_XML_SCHEMAP_SRC_INCLUDE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ATTRIBUTE_1", exports_XML_SCHEMAP_SRC_ATTRIBUTE_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ATTRIBUTE_2", exports_XML_SCHEMAP_SRC_ATTRIBUTE_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ATTRIBUTE_3_1", exports_XML_SCHEMAP_SRC_ATTRIBUTE_3_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ATTRIBUTE_3_2", exports_XML_SCHEMAP_SRC_ATTRIBUTE_3_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ATTRIBUTE_4", exports_XML_SCHEMAP_SRC_ATTRIBUTE_4_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NO_XMLNS", exports_XML_SCHEMAP_NO_XMLNS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NO_XSI", exports_XML_SCHEMAP_NO_XSI_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_VALID_DEFAULT_1", exports_XML_SCHEMAP_COS_VALID_DEFAULT_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_VALID_DEFAULT_2_1", exports_XML_SCHEMAP_COS_VALID_DEFAULT_2_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1", exports_XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2", exports_XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_CVC_SIMPLE_TYPE", exports_XML_SCHEMAP_CVC_SIMPLE_TYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_CT_EXTENDS_1_1", exports_XML_SCHEMAP_COS_CT_EXTENDS_1_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_IMPORT_1_1", exports_XML_SCHEMAP_SRC_IMPORT_1_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_IMPORT_1_2", exports_XML_SCHEMAP_SRC_IMPORT_1_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_IMPORT_2", exports_XML_SCHEMAP_SRC_IMPORT_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_IMPORT_2_1", exports_XML_SCHEMAP_SRC_IMPORT_2_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_IMPORT_2_2", exports_XML_SCHEMAP_SRC_IMPORT_2_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INTERNAL", exports_XML_SCHEMAP_INTERNAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NOT_DETERMINISTIC", exports_XML_SCHEMAP_NOT_DETERMINISTIC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1", exports_XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2", exports_XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3", exports_XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_MG_PROPS_CORRECT_1", exports_XML_SCHEMAP_MG_PROPS_CORRECT_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_MG_PROPS_CORRECT_2", exports_XML_SCHEMAP_MG_PROPS_CORRECT_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_CT_1", exports_XML_SCHEMAP_SRC_CT_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3", exports_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_AU_PROPS_CORRECT_2", exports_XML_SCHEMAP_AU_PROPS_CORRECT_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_A_PROPS_CORRECT_2", exports_XML_SCHEMAP_A_PROPS_CORRECT_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_C_PROPS_CORRECT", exports_XML_SCHEMAP_C_PROPS_CORRECT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_REDEFINE", exports_XML_SCHEMAP_SRC_REDEFINE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_IMPORT", exports_XML_SCHEMAP_SRC_IMPORT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_WARN_SKIP_SCHEMA", exports_XML_SCHEMAP_WARN_SKIP_SCHEMA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_WARN_UNLOCATED_SCHEMA", exports_XML_SCHEMAP_WARN_UNLOCATED_SCHEMA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_WARN_ATTR_REDECL_PROH", exports_XML_SCHEMAP_WARN_ATTR_REDECL_PROH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH", exports_XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_AG_PROPS_CORRECT", exports_XML_SCHEMAP_AG_PROPS_CORRECT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_CT_EXTENDS_1_2", exports_XML_SCHEMAP_COS_CT_EXTENDS_1_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_AU_PROPS_CORRECT", exports_XML_SCHEMAP_AU_PROPS_CORRECT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_A_PROPS_CORRECT_3", exports_XML_SCHEMAP_A_PROPS_CORRECT_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ALL_LIMITED", exports_XML_SCHEMAP_COS_ALL_LIMITED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMATRONV_ASSERT", exports_XML_SCHEMATRONV_ASSERT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMATRONV_REPORT", exports_XML_SCHEMATRONV_REPORT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_MODULE_OPEN", exports_XML_MODULE_OPEN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_MODULE_CLOSE", exports_XML_MODULE_CLOSE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_ELEMENT", exports_XML_CHECK_FOUND_ELEMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_ATTRIBUTE", exports_XML_CHECK_FOUND_ATTRIBUTE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_TEXT", exports_XML_CHECK_FOUND_TEXT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_CDATA", exports_XML_CHECK_FOUND_CDATA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_ENTITYREF", exports_XML_CHECK_FOUND_ENTITYREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_ENTITY", exports_XML_CHECK_FOUND_ENTITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_PI", exports_XML_CHECK_FOUND_PI_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_COMMENT", exports_XML_CHECK_FOUND_COMMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_DOCTYPE", exports_XML_CHECK_FOUND_DOCTYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_FRAGMENT", exports_XML_CHECK_FOUND_FRAGMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_NOTATION", exports_XML_CHECK_FOUND_NOTATION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_UNKNOWN_NODE", exports_XML_CHECK_UNKNOWN_NODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_ENTITY_TYPE", exports_XML_CHECK_ENTITY_TYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NO_PARENT", exports_XML_CHECK_NO_PARENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NO_DOC", exports_XML_CHECK_NO_DOC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NO_NAME", exports_XML_CHECK_NO_NAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NO_ELEM", exports_XML_CHECK_NO_ELEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_WRONG_DOC", exports_XML_CHECK_WRONG_DOC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NO_PREV", exports_XML_CHECK_NO_PREV_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_WRONG_PREV", exports_XML_CHECK_WRONG_PREV_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NO_NEXT", exports_XML_CHECK_NO_NEXT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_WRONG_NEXT", exports_XML_CHECK_WRONG_NEXT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NOT_DTD", exports_XML_CHECK_NOT_DTD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NOT_ATTR", exports_XML_CHECK_NOT_ATTR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NOT_ATTR_DECL", exports_XML_CHECK_NOT_ATTR_DECL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NOT_ELEM_DECL", exports_XML_CHECK_NOT_ELEM_DECL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NOT_ENTITY_DECL", exports_XML_CHECK_NOT_ENTITY_DECL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NOT_NS_DECL", exports_XML_CHECK_NOT_NS_DECL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NO_HREF", exports_XML_CHECK_NO_HREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_WRONG_PARENT", exports_XML_CHECK_WRONG_PARENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NS_SCOPE", exports_XML_CHECK_NS_SCOPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NS_ANCESTOR", exports_XML_CHECK_NS_ANCESTOR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NOT_UTF8", exports_XML_CHECK_NOT_UTF8_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NO_DICT", exports_XML_CHECK_NO_DICT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NOT_NCNAME", exports_XML_CHECK_NOT_NCNAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_OUTSIDE_DICT", exports_XML_CHECK_OUTSIDE_DICT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_WRONG_NAME", exports_XML_CHECK_WRONG_NAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NAME_NOT_NULL", exports_XML_CHECK_NAME_NOT_NULL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_I18N_NO_NAME", exports_XML_I18N_NO_NAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_I18N_NO_HANDLER", exports_XML_I18N_NO_HANDLER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_I18N_EXCESS_HANDLER", exports_XML_I18N_EXCESS_HANDLER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_I18N_CONV_FAILED", exports_XML_I18N_CONV_FAILED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_I18N_NO_OUTPUT", exports_XML_I18N_NO_OUTPUT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_BUF_OVERFLOW", exports_XML_BUF_OVERFLOW_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlValidCtxt_class, "userData", _wrap__xmlValidCtxt_userData_get, _wrap__xmlValidCtxt_userData_set);
SWIGV8_AddMemberVariable(_exports__xmlValidCtxt_class, "error", _wrap__xmlValidCtxt_error_get, _wrap__xmlValidCtxt_error_set);
SWIGV8_AddMemberVariable(_exports__xmlValidCtxt_class, "warning", _wrap__xmlValidCtxt_warning_get, _wrap__xmlValidCtxt_warning_set);
SWIGV8_AddMemberVariable(_exports__xmlValidCtxt_class, "node", _wrap__xmlValidCtxt_node_get, _wrap__xmlValidCtxt_node_set);
SWIGV8_AddMemberVariable(_exports__xmlValidCtxt_class, "nodeNr", _wrap__xmlValidCtxt_nodeNr_get, _wrap__xmlValidCtxt_nodeNr_set);
SWIGV8_AddMemberVariable(_exports__xmlValidCtxt_class, "nodeMax", _wrap__xmlValidCtxt_nodeMax_get, _wrap__xmlValidCtxt_nodeMax_set);
SWIGV8_AddMemberVariable(_exports__xmlValidCtxt_class, "nodeTab", _wrap__xmlValidCtxt_nodeTab_get, _wrap__xmlValidCtxt_nodeTab_set);
SWIGV8_AddMemberVariable(_exports__xmlValidCtxt_class, "flags", _wrap__xmlValidCtxt_flags_get, _wrap__xmlValidCtxt_flags_set);
SWIGV8_AddMemberVariable(_exports__xmlValidCtxt_class, "doc", _wrap__xmlValidCtxt_doc_get, _wrap__xmlValidCtxt_doc_set);
SWIGV8_AddMemberVariable(_exports__xmlValidCtxt_class, "valid", _wrap__xmlValidCtxt_valid_get, _wrap__xmlValidCtxt_valid_set);
SWIGV8_AddMemberVariable(_exports__xmlValidCtxt_class, "vstate", _wrap__xmlValidCtxt_vstate_get, _wrap__xmlValidCtxt_vstate_set);
SWIGV8_AddMemberVariable(_exports__xmlValidCtxt_class, "vstateNr", _wrap__xmlValidCtxt_vstateNr_get, _wrap__xmlValidCtxt_vstateNr_set);
SWIGV8_AddMemberVariable(_exports__xmlValidCtxt_class, "vstateMax", _wrap__xmlValidCtxt_vstateMax_get, _wrap__xmlValidCtxt_vstateMax_set);
SWIGV8_AddMemberVariable(_exports__xmlValidCtxt_class, "vstateTab", _wrap__xmlValidCtxt_vstateTab_get, _wrap__xmlValidCtxt_vstateTab_set);
SWIGV8_AddMemberVariable(_exports__xmlValidCtxt_class, "am", _wrap__xmlValidCtxt_am_get, _wrap__xmlValidCtxt_am_set);
SWIGV8_AddMemberVariable(_exports__xmlValidCtxt_class, "state", _wrap__xmlValidCtxt_state_get, _wrap__xmlValidCtxt_state_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_INTERNAL_GENERAL_ENTITY", exports_XML_INTERNAL_GENERAL_ENTITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_EXTERNAL_GENERAL_PARSED_ENTITY", exports_XML_EXTERNAL_GENERAL_PARSED_ENTITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_EXTERNAL_GENERAL_UNPARSED_ENTITY", exports_XML_EXTERNAL_GENERAL_UNPARSED_ENTITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_INTERNAL_PARAMETER_ENTITY", exports_XML_INTERNAL_PARAMETER_ENTITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_EXTERNAL_PARAMETER_ENTITY", exports_XML_EXTERNAL_PARAMETER_ENTITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_INTERNAL_PREDEFINED_ENTITY", exports_XML_INTERNAL_PREDEFINED_ENTITY_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "flags", _wrap__xmlEntity_flags_get, _wrap__xmlEntity_flags_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "expandedSize", _wrap__xmlEntity_expandedSize_get, _wrap__xmlEntity_expandedSize_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "_private", _wrap__xmlEntity__private_get, _wrap__xmlEntity__private_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "type", _wrap__xmlEntity_type_get, _wrap__xmlEntity_type_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "name", _wrap__xmlEntity_name_get, _wrap__xmlEntity_name_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "children", _wrap__xmlEntity_children_get, _wrap__xmlEntity_children_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "last", _wrap__xmlEntity_last_get, _wrap__xmlEntity_last_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "parent", _wrap__xmlEntity_parent_get, _wrap__xmlEntity_parent_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "next", _wrap__xmlEntity_next_get, _wrap__xmlEntity_next_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "prev", _wrap__xmlEntity_prev_get, _wrap__xmlEntity_prev_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "doc", _wrap__xmlEntity_doc_get, _wrap__xmlEntity_doc_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "orig", _wrap__xmlEntity_orig_get, _wrap__xmlEntity_orig_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "content", _wrap__xmlEntity_content_get, _wrap__xmlEntity_content_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "length", _wrap__xmlEntity_length_get, _wrap__xmlEntity_length_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "etype", _wrap__xmlEntity_etype_get, _wrap__xmlEntity_etype_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "ExternalID", _wrap__xmlEntity_ExternalID_get, _wrap__xmlEntity_ExternalID_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "SystemID", _wrap__xmlEntity_SystemID_get, _wrap__xmlEntity_SystemID_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "nexte", _wrap__xmlEntity_nexte_get, _wrap__xmlEntity_nexte_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "URI", _wrap__xmlEntity_URI_get, _wrap__xmlEntity_URI_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "owner", _wrap__xmlEntity_owner_get, _wrap__xmlEntity_owner_set);
SWIGV8_AddMemberVariable(_exports__xmlEntity_class, "checked", _wrap__xmlEntity_checked_get, _wrap__xmlEntity_checked_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_ENC_ERR_SUCCESS", exports_XML_ENC_ERR_SUCCESS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ENC_ERR_SPACE", exports_XML_ENC_ERR_SPACE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ENC_ERR_INPUT", exports_XML_ENC_ERR_INPUT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ENC_ERR_PARTIAL", exports_XML_ENC_ERR_PARTIAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ENC_ERR_INTERNAL", exports_XML_ENC_ERR_INTERNAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ENC_ERR_MEMORY", exports_XML_ENC_ERR_MEMORY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_ERROR", exports_XML_CHAR_ENCODING_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_NONE", exports_XML_CHAR_ENCODING_NONE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_UTF8", exports_XML_CHAR_ENCODING_UTF8_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_UTF16LE", exports_XML_CHAR_ENCODING_UTF16LE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_UTF16BE", exports_XML_CHAR_ENCODING_UTF16BE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_UCS4LE", exports_XML_CHAR_ENCODING_UCS4LE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_UCS4BE", exports_XML_CHAR_ENCODING_UCS4BE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_EBCDIC", exports_XML_CHAR_ENCODING_EBCDIC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_UCS4_2143", exports_XML_CHAR_ENCODING_UCS4_2143_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_UCS4_3412", exports_XML_CHAR_ENCODING_UCS4_3412_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_UCS2", exports_XML_CHAR_ENCODING_UCS2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_1", exports_XML_CHAR_ENCODING_8859_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_2", exports_XML_CHAR_ENCODING_8859_2_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_3", exports_XML_CHAR_ENCODING_8859_3_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_4", exports_XML_CHAR_ENCODING_8859_4_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_5", exports_XML_CHAR_ENCODING_8859_5_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_6", exports_XML_CHAR_ENCODING_8859_6_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_7", exports_XML_CHAR_ENCODING_8859_7_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_8", exports_XML_CHAR_ENCODING_8859_8_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_9", exports_XML_CHAR_ENCODING_8859_9_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_2022_JP", exports_XML_CHAR_ENCODING_2022_JP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_SHIFT_JIS", exports_XML_CHAR_ENCODING_SHIFT_JIS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_EUC_JP", exports_XML_CHAR_ENCODING_EUC_JP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_ASCII", exports_XML_CHAR_ENCODING_ASCII_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlCharEncodingHandler_class, "name", _wrap__xmlCharEncodingHandler_name_get, _wrap__xmlCharEncodingHandler_name_set);
SWIGV8_AddMemberVariable(_exports__xmlCharEncodingHandler_class, "input", _wrap__xmlCharEncodingHandler_input_get, _wrap__xmlCharEncodingHandler_input_set);
SWIGV8_AddMemberVariable(_exports__xmlCharEncodingHandler_class, "output", _wrap__xmlCharEncodingHandler_output_get, _wrap__xmlCharEncodingHandler_output_set);
SWIGV8_AddMemberVariable(_exports__xmlCharEncodingHandler_class, "iconv_in", _wrap__xmlCharEncodingHandler_iconv_in_get, _wrap__xmlCharEncodingHandler_iconv_in_set);
SWIGV8_AddMemberVariable(_exports__xmlCharEncodingHandler_class, "iconv_out", _wrap__xmlCharEncodingHandler_iconv_out_get, _wrap__xmlCharEncodingHandler_iconv_out_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInputBuffer_class, "context", _wrap__xmlParserInputBuffer_context_get, _wrap__xmlParserInputBuffer_context_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInputBuffer_class, "readcallback", _wrap__xmlParserInputBuffer_readcallback_get, _wrap__xmlParserInputBuffer_readcallback_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInputBuffer_class, "closecallback", _wrap__xmlParserInputBuffer_closecallback_get, _wrap__xmlParserInputBuffer_closecallback_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInputBuffer_class, "encoder", _wrap__xmlParserInputBuffer_encoder_get, _wrap__xmlParserInputBuffer_encoder_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInputBuffer_class, "buffer", _wrap__xmlParserInputBuffer_buffer_get, _wrap__xmlParserInputBuffer_buffer_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInputBuffer_class, "raw", _wrap__xmlParserInputBuffer_raw_get, _wrap__xmlParserInputBuffer_raw_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInputBuffer_class, "compressed", _wrap__xmlParserInputBuffer_compressed_get, _wrap__xmlParserInputBuffer_compressed_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInputBuffer_class, "error", _wrap__xmlParserInputBuffer_error_get, _wrap__xmlParserInputBuffer_error_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInputBuffer_class, "rawconsumed", _wrap__xmlParserInputBuffer_rawconsumed_get, _wrap__xmlParserInputBuffer_rawconsumed_set);
SWIGV8_AddMemberVariable(_exports__xmlOutputBuffer_class, "context", _wrap__xmlOutputBuffer_context_get, _wrap__xmlOutputBuffer_context_set);
SWIGV8_AddMemberVariable(_exports__xmlOutputBuffer_class, "writecallback", _wrap__xmlOutputBuffer_writecallback_get, _wrap__xmlOutputBuffer_writecallback_set);
SWIGV8_AddMemberVariable(_exports__xmlOutputBuffer_class, "closecallback", _wrap__xmlOutputBuffer_closecallback_get, _wrap__xmlOutputBuffer_closecallback_set);
SWIGV8_AddMemberVariable(_exports__xmlOutputBuffer_class, "encoder", _wrap__xmlOutputBuffer_encoder_get, _wrap__xmlOutputBuffer_encoder_set);
SWIGV8_AddMemberVariable(_exports__xmlOutputBuffer_class, "buffer", _wrap__xmlOutputBuffer_buffer_get, _wrap__xmlOutputBuffer_buffer_set);
SWIGV8_AddMemberVariable(_exports__xmlOutputBuffer_class, "conv", _wrap__xmlOutputBuffer_conv_get, _wrap__xmlOutputBuffer_conv_set);
SWIGV8_AddMemberVariable(_exports__xmlOutputBuffer_class, "written", _wrap__xmlOutputBuffer_written_get, _wrap__xmlOutputBuffer_written_set);
SWIGV8_AddMemberVariable(_exports__xmlOutputBuffer_class, "error", _wrap__xmlOutputBuffer_error_get, _wrap__xmlOutputBuffer_error_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_DEFAULT_VERSION", exports_XML_DEFAULT_VERSION_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "buf", _wrap__xmlParserInput_buf_get, _wrap__xmlParserInput_buf_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "filename", _wrap__xmlParserInput_filename_get, _wrap__xmlParserInput_filename_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "directory", _wrap__xmlParserInput_directory_get, _wrap__xmlParserInput_directory_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "base", _wrap__xmlParserInput_base_get, _wrap__xmlParserInput_base_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "cur", _wrap__xmlParserInput_cur_get, _wrap__xmlParserInput_cur_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "end", _wrap__xmlParserInput_end_get, _wrap__xmlParserInput_end_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "length", _wrap__xmlParserInput_length_get, _wrap__xmlParserInput_length_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "line", _wrap__xmlParserInput_line_get, _wrap__xmlParserInput_line_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "col", _wrap__xmlParserInput_col_get, _wrap__xmlParserInput_col_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "consumed", _wrap__xmlParserInput_consumed_get, _wrap__xmlParserInput_consumed_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "free", _wrap__xmlParserInput_free_get, _wrap__xmlParserInput_free_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "encoding", _wrap__xmlParserInput_encoding_get, _wrap__xmlParserInput_encoding_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "version", _wrap__xmlParserInput_version_get, _wrap__xmlParserInput_version_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "flags", _wrap__xmlParserInput_flags_get, _wrap__xmlParserInput_flags_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "id", _wrap__xmlParserInput_id_get, _wrap__xmlParserInput_id_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "parentConsumed", _wrap__xmlParserInput_parentConsumed_get, _wrap__xmlParserInput_parentConsumed_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "entity", _wrap__xmlParserInput_entity_get, _wrap__xmlParserInput_entity_set);
SWIGV8_AddMemberVariable(_exports__xmlParserNodeInfo_class, "node", _wrap__xmlParserNodeInfo_node_get, _wrap__xmlParserNodeInfo_node_set);
SWIGV8_AddMemberVariable(_exports__xmlParserNodeInfo_class, "begin_pos", _wrap__xmlParserNodeInfo_begin_pos_get, _wrap__xmlParserNodeInfo_begin_pos_set);
SWIGV8_AddMemberVariable(_exports__xmlParserNodeInfo_class, "begin_line", _wrap__xmlParserNodeInfo_begin_line_get, _wrap__xmlParserNodeInfo_begin_line_set);
SWIGV8_AddMemberVariable(_exports__xmlParserNodeInfo_class, "end_pos", _wrap__xmlParserNodeInfo_end_pos_get, _wrap__xmlParserNodeInfo_end_pos_set);
SWIGV8_AddMemberVariable(_exports__xmlParserNodeInfo_class, "end_line", _wrap__xmlParserNodeInfo_end_line_get, _wrap__xmlParserNodeInfo_end_line_set);
SWIGV8_AddMemberVariable(_exports__xmlParserNodeInfoSeq_class, "maximum", _wrap__xmlParserNodeInfoSeq_maximum_get, _wrap__xmlParserNodeInfoSeq_maximum_set);
SWIGV8_AddMemberVariable(_exports__xmlParserNodeInfoSeq_class, "length", _wrap__xmlParserNodeInfoSeq_length_get, _wrap__xmlParserNodeInfoSeq_length_set);
SWIGV8_AddMemberVariable(_exports__xmlParserNodeInfoSeq_class, "buffer", _wrap__xmlParserNodeInfoSeq_buffer_get, _wrap__xmlParserNodeInfoSeq_buffer_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_EOF", exports_XML_PARSER_EOF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_START", exports_XML_PARSER_START_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_MISC", exports_XML_PARSER_MISC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_PI", exports_XML_PARSER_PI_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_DTD", exports_XML_PARSER_DTD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_PROLOG", exports_XML_PARSER_PROLOG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_COMMENT", exports_XML_PARSER_COMMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_START_TAG", exports_XML_PARSER_START_TAG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_CONTENT", exports_XML_PARSER_CONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_CDATA_SECTION", exports_XML_PARSER_CDATA_SECTION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_END_TAG", exports_XML_PARSER_END_TAG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_ENTITY_DECL", exports_XML_PARSER_ENTITY_DECL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_ENTITY_VALUE", exports_XML_PARSER_ENTITY_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_ATTRIBUTE_VALUE", exports_XML_PARSER_ATTRIBUTE_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_SYSTEM_LITERAL", exports_XML_PARSER_SYSTEM_LITERAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_EPILOG", exports_XML_PARSER_EPILOG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_IGNORE", exports_XML_PARSER_IGNORE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_PUBLIC_LITERAL", exports_XML_PARSER_PUBLIC_LITERAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_XML_DECL", exports_XML_PARSER_XML_DECL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DETECT_IDS", exports_XML_DETECT_IDS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_COMPLETE_ATTRS", exports_XML_COMPLETE_ATTRS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SKIP_IDS", exports_XML_SKIP_IDS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_UNKNOWN", exports_XML_PARSE_UNKNOWN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_DOM", exports_XML_PARSE_DOM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_SAX", exports_XML_PARSE_SAX_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_PUSH_DOM", exports_XML_PARSE_PUSH_DOM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_PUSH_SAX", exports_XML_PARSE_PUSH_SAX_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_READER", exports_XML_PARSE_READER_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "sax", _wrap__xmlParserCtxt_sax_get, _wrap__xmlParserCtxt_sax_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "userData", _wrap__xmlParserCtxt_userData_get, _wrap__xmlParserCtxt_userData_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "myDoc", _wrap__xmlParserCtxt_myDoc_get, _wrap__xmlParserCtxt_myDoc_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "wellFormed", _wrap__xmlParserCtxt_wellFormed_get, _wrap__xmlParserCtxt_wellFormed_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "replaceEntities", _wrap__xmlParserCtxt_replaceEntities_get, _wrap__xmlParserCtxt_replaceEntities_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "version", _wrap__xmlParserCtxt_version_get, _wrap__xmlParserCtxt_version_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "encoding", _wrap__xmlParserCtxt_encoding_get, _wrap__xmlParserCtxt_encoding_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "standalone", _wrap__xmlParserCtxt_standalone_get, _wrap__xmlParserCtxt_standalone_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "html", _wrap__xmlParserCtxt_html_get, _wrap__xmlParserCtxt_html_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "input", _wrap__xmlParserCtxt_input_get, _wrap__xmlParserCtxt_input_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "inputNr", _wrap__xmlParserCtxt_inputNr_get, _wrap__xmlParserCtxt_inputNr_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "inputMax", _wrap__xmlParserCtxt_inputMax_get, _wrap__xmlParserCtxt_inputMax_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "inputTab", _wrap__xmlParserCtxt_inputTab_get, _wrap__xmlParserCtxt_inputTab_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "node", _wrap__xmlParserCtxt_node_get, _wrap__xmlParserCtxt_node_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nodeNr", _wrap__xmlParserCtxt_nodeNr_get, _wrap__xmlParserCtxt_nodeNr_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nodeMax", _wrap__xmlParserCtxt_nodeMax_get, _wrap__xmlParserCtxt_nodeMax_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nodeTab", _wrap__xmlParserCtxt_nodeTab_get, _wrap__xmlParserCtxt_nodeTab_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "record_info", _wrap__xmlParserCtxt_record_info_get, _wrap__xmlParserCtxt_record_info_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "node_seq", _wrap__xmlParserCtxt_node_seq_get, _wrap__xmlParserCtxt_node_seq_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "errNo", _wrap__xmlParserCtxt_errNo_get, _wrap__xmlParserCtxt_errNo_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "hasExternalSubset", _wrap__xmlParserCtxt_hasExternalSubset_get, _wrap__xmlParserCtxt_hasExternalSubset_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "hasPErefs", _wrap__xmlParserCtxt_hasPErefs_get, _wrap__xmlParserCtxt_hasPErefs_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "external", _wrap__xmlParserCtxt_external_get, _wrap__xmlParserCtxt_external_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "valid", _wrap__xmlParserCtxt_valid_get, _wrap__xmlParserCtxt_valid_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "validate", _wrap__xmlParserCtxt_validate_get, _wrap__xmlParserCtxt_validate_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "vctxt", _wrap__xmlParserCtxt_vctxt_get, _wrap__xmlParserCtxt_vctxt_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "instate", _wrap__xmlParserCtxt_instate_get, _wrap__xmlParserCtxt_instate_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "token", _wrap__xmlParserCtxt_token_get, _wrap__xmlParserCtxt_token_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "directory", _wrap__xmlParserCtxt_directory_get, _wrap__xmlParserCtxt_directory_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "name", _wrap__xmlParserCtxt_name_get, _wrap__xmlParserCtxt_name_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nameNr", _wrap__xmlParserCtxt_nameNr_get, _wrap__xmlParserCtxt_nameNr_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nameMax", _wrap__xmlParserCtxt_nameMax_get, _wrap__xmlParserCtxt_nameMax_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nameTab", _wrap__xmlParserCtxt_nameTab_get, _wrap__xmlParserCtxt_nameTab_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nbChars", _wrap__xmlParserCtxt_nbChars_get, _wrap__xmlParserCtxt_nbChars_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "checkIndex", _wrap__xmlParserCtxt_checkIndex_get, _wrap__xmlParserCtxt_checkIndex_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "keepBlanks", _wrap__xmlParserCtxt_keepBlanks_get, _wrap__xmlParserCtxt_keepBlanks_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "disableSAX", _wrap__xmlParserCtxt_disableSAX_get, _wrap__xmlParserCtxt_disableSAX_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "inSubset", _wrap__xmlParserCtxt_inSubset_get, _wrap__xmlParserCtxt_inSubset_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "intSubName", _wrap__xmlParserCtxt_intSubName_get, _wrap__xmlParserCtxt_intSubName_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "extSubURI", _wrap__xmlParserCtxt_extSubURI_get, _wrap__xmlParserCtxt_extSubURI_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "extSubSystem", _wrap__xmlParserCtxt_extSubSystem_get, _wrap__xmlParserCtxt_extSubSystem_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "space", _wrap__xmlParserCtxt_space_get, _wrap__xmlParserCtxt_space_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "spaceNr", _wrap__xmlParserCtxt_spaceNr_get, _wrap__xmlParserCtxt_spaceNr_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "spaceMax", _wrap__xmlParserCtxt_spaceMax_get, _wrap__xmlParserCtxt_spaceMax_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "spaceTab", _wrap__xmlParserCtxt_spaceTab_get, _wrap__xmlParserCtxt_spaceTab_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "depth", _wrap__xmlParserCtxt_depth_get, _wrap__xmlParserCtxt_depth_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "entity", _wrap__xmlParserCtxt_entity_get, _wrap__xmlParserCtxt_entity_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "charset", _wrap__xmlParserCtxt_charset_get, _wrap__xmlParserCtxt_charset_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nodelen", _wrap__xmlParserCtxt_nodelen_get, _wrap__xmlParserCtxt_nodelen_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nodemem", _wrap__xmlParserCtxt_nodemem_get, _wrap__xmlParserCtxt_nodemem_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "pedantic", _wrap__xmlParserCtxt_pedantic_get, _wrap__xmlParserCtxt_pedantic_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "_private", _wrap__xmlParserCtxt__private_get, _wrap__xmlParserCtxt__private_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "loadsubset", _wrap__xmlParserCtxt_loadsubset_get, _wrap__xmlParserCtxt_loadsubset_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "linenumbers", _wrap__xmlParserCtxt_linenumbers_get, _wrap__xmlParserCtxt_linenumbers_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "catalogs", _wrap__xmlParserCtxt_catalogs_get, _wrap__xmlParserCtxt_catalogs_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "recovery", _wrap__xmlParserCtxt_recovery_get, _wrap__xmlParserCtxt_recovery_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "progressive", _wrap__xmlParserCtxt_progressive_get, _wrap__xmlParserCtxt_progressive_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "dict", _wrap__xmlParserCtxt_dict_get, _wrap__xmlParserCtxt_dict_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "atts", _wrap__xmlParserCtxt_atts_get, _wrap__xmlParserCtxt_atts_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "maxatts", _wrap__xmlParserCtxt_maxatts_get, _wrap__xmlParserCtxt_maxatts_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "docdict", _wrap__xmlParserCtxt_docdict_get, _wrap__xmlParserCtxt_docdict_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "str_xml", _wrap__xmlParserCtxt_str_xml_get, _wrap__xmlParserCtxt_str_xml_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "str_xmlns", _wrap__xmlParserCtxt_str_xmlns_get, _wrap__xmlParserCtxt_str_xmlns_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "str_xml_ns", _wrap__xmlParserCtxt_str_xml_ns_get, _wrap__xmlParserCtxt_str_xml_ns_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "sax2", _wrap__xmlParserCtxt_sax2_get, _wrap__xmlParserCtxt_sax2_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nsNr", _wrap__xmlParserCtxt_nsNr_get, _wrap__xmlParserCtxt_nsNr_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nsMax", _wrap__xmlParserCtxt_nsMax_get, _wrap__xmlParserCtxt_nsMax_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nsTab", _wrap__xmlParserCtxt_nsTab_get, _wrap__xmlParserCtxt_nsTab_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "attallocs", _wrap__xmlParserCtxt_attallocs_get, _wrap__xmlParserCtxt_attallocs_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "pushTab", _wrap__xmlParserCtxt_pushTab_get, _wrap__xmlParserCtxt_pushTab_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "attsDefault", _wrap__xmlParserCtxt_attsDefault_get, _wrap__xmlParserCtxt_attsDefault_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "attsSpecial", _wrap__xmlParserCtxt_attsSpecial_get, _wrap__xmlParserCtxt_attsSpecial_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nsWellFormed", _wrap__xmlParserCtxt_nsWellFormed_get, _wrap__xmlParserCtxt_nsWellFormed_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "options", _wrap__xmlParserCtxt_options_get, _wrap__xmlParserCtxt_options_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "dictNames", _wrap__xmlParserCtxt_dictNames_get, _wrap__xmlParserCtxt_dictNames_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "freeElemsNr", _wrap__xmlParserCtxt_freeElemsNr_get, _wrap__xmlParserCtxt_freeElemsNr_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "freeElems", _wrap__xmlParserCtxt_freeElems_get, _wrap__xmlParserCtxt_freeElems_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "freeAttrsNr", _wrap__xmlParserCtxt_freeAttrsNr_get, _wrap__xmlParserCtxt_freeAttrsNr_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "freeAttrs", _wrap__xmlParserCtxt_freeAttrs_get, _wrap__xmlParserCtxt_freeAttrs_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "lastError", _wrap__xmlParserCtxt_lastError_get, _wrap__xmlParserCtxt_lastError_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "parseMode", _wrap__xmlParserCtxt_parseMode_get, _wrap__xmlParserCtxt_parseMode_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nbentities", _wrap__xmlParserCtxt_nbentities_get, _wrap__xmlParserCtxt_nbentities_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "sizeentities", _wrap__xmlParserCtxt_sizeentities_get, _wrap__xmlParserCtxt_sizeentities_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nodeInfo", _wrap__xmlParserCtxt_nodeInfo_get, _wrap__xmlParserCtxt_nodeInfo_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nodeInfoNr", _wrap__xmlParserCtxt_nodeInfoNr_get, _wrap__xmlParserCtxt_nodeInfoNr_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nodeInfoMax", _wrap__xmlParserCtxt_nodeInfoMax_get, _wrap__xmlParserCtxt_nodeInfoMax_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nodeInfoTab", _wrap__xmlParserCtxt_nodeInfoTab_get, _wrap__xmlParserCtxt_nodeInfoTab_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "input_id", _wrap__xmlParserCtxt_input_id_get, _wrap__xmlParserCtxt_input_id_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "sizeentcopy", _wrap__xmlParserCtxt_sizeentcopy_get, _wrap__xmlParserCtxt_sizeentcopy_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "endCheckState", _wrap__xmlParserCtxt_endCheckState_get, _wrap__xmlParserCtxt_endCheckState_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nbErrors", _wrap__xmlParserCtxt_nbErrors_get, _wrap__xmlParserCtxt_nbErrors_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nbWarnings", _wrap__xmlParserCtxt_nbWarnings_get, _wrap__xmlParserCtxt_nbWarnings_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "maxAmpl", _wrap__xmlParserCtxt_maxAmpl_get, _wrap__xmlParserCtxt_maxAmpl_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "nsdb", _wrap__xmlParserCtxt_nsdb_get, _wrap__xmlParserCtxt_nsdb_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "attrHashMax", _wrap__xmlParserCtxt_attrHashMax_get, _wrap__xmlParserCtxt_attrHashMax_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "attrHash", _wrap__xmlParserCtxt_attrHash_get, _wrap__xmlParserCtxt_attrHash_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "errorHandler", _wrap__xmlParserCtxt_errorHandler_get, _wrap__xmlParserCtxt_errorHandler_set);
SWIGV8_AddMemberVariable(_exports__xmlParserCtxt_class, "errorCtxt", _wrap__xmlParserCtxt_errorCtxt_get, _wrap__xmlParserCtxt_errorCtxt_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXLocator_class, "getPublicId", _wrap__xmlSAXLocator_getPublicId_get, _wrap__xmlSAXLocator_getPublicId_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXLocator_class, "getSystemId", _wrap__xmlSAXLocator_getSystemId_get, _wrap__xmlSAXLocator_getSystemId_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXLocator_class, "getLineNumber", _wrap__xmlSAXLocator_getLineNumber_get, _wrap__xmlSAXLocator_getLineNumber_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXLocator_class, "getColumnNumber", _wrap__xmlSAXLocator_getColumnNumber_get, _wrap__xmlSAXLocator_getColumnNumber_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAX2_MAGIC", exports_XML_SAX2_MAGIC_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "internalSubset", _wrap__xmlSAXHandler_internalSubset_get, _wrap__xmlSAXHandler_internalSubset_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "isStandalone", _wrap__xmlSAXHandler_isStandalone_get, _wrap__xmlSAXHandler_isStandalone_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "hasInternalSubset", _wrap__xmlSAXHandler_hasInternalSubset_get, _wrap__xmlSAXHandler_hasInternalSubset_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "hasExternalSubset", _wrap__xmlSAXHandler_hasExternalSubset_get, _wrap__xmlSAXHandler_hasExternalSubset_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "resolveEntity", _wrap__xmlSAXHandler_resolveEntity_get, _wrap__xmlSAXHandler_resolveEntity_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "getEntity", _wrap__xmlSAXHandler_getEntity_get, _wrap__xmlSAXHandler_getEntity_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "entityDecl", _wrap__xmlSAXHandler_entityDecl_get, _wrap__xmlSAXHandler_entityDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "notationDecl", _wrap__xmlSAXHandler_notationDecl_get, _wrap__xmlSAXHandler_notationDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "attributeDecl", _wrap__xmlSAXHandler_attributeDecl_get, _wrap__xmlSAXHandler_attributeDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "elementDecl", _wrap__xmlSAXHandler_elementDecl_get, _wrap__xmlSAXHandler_elementDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "unparsedEntityDecl", _wrap__xmlSAXHandler_unparsedEntityDecl_get, _wrap__xmlSAXHandler_unparsedEntityDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "setDocumentLocator", _wrap__xmlSAXHandler_setDocumentLocator_get, _wrap__xmlSAXHandler_setDocumentLocator_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "startDocument", _wrap__xmlSAXHandler_startDocument_get, _wrap__xmlSAXHandler_startDocument_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "endDocument", _wrap__xmlSAXHandler_endDocument_get, _wrap__xmlSAXHandler_endDocument_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "startElement", _wrap__xmlSAXHandler_startElement_get, _wrap__xmlSAXHandler_startElement_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "endElement", _wrap__xmlSAXHandler_endElement_get, _wrap__xmlSAXHandler_endElement_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "reference", _wrap__xmlSAXHandler_reference_get, _wrap__xmlSAXHandler_reference_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "characters", _wrap__xmlSAXHandler_characters_get, _wrap__xmlSAXHandler_characters_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "ignorableWhitespace", _wrap__xmlSAXHandler_ignorableWhitespace_get, _wrap__xmlSAXHandler_ignorableWhitespace_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "processingInstruction", _wrap__xmlSAXHandler_processingInstruction_get, _wrap__xmlSAXHandler_processingInstruction_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "comment", _wrap__xmlSAXHandler_comment_get, _wrap__xmlSAXHandler_comment_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "warning", _wrap__xmlSAXHandler_warning_get, _wrap__xmlSAXHandler_warning_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "error", _wrap__xmlSAXHandler_error_get, _wrap__xmlSAXHandler_error_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "fatalError", _wrap__xmlSAXHandler_fatalError_get, _wrap__xmlSAXHandler_fatalError_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "getParameterEntity", _wrap__xmlSAXHandler_getParameterEntity_get, _wrap__xmlSAXHandler_getParameterEntity_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "cdataBlock", _wrap__xmlSAXHandler_cdataBlock_get, _wrap__xmlSAXHandler_cdataBlock_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "externalSubset", _wrap__xmlSAXHandler_externalSubset_get, _wrap__xmlSAXHandler_externalSubset_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "initialized", _wrap__xmlSAXHandler_initialized_get, _wrap__xmlSAXHandler_initialized_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "_private", _wrap__xmlSAXHandler__private_get, _wrap__xmlSAXHandler__private_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "startElementNs", _wrap__xmlSAXHandler_startElementNs_get, _wrap__xmlSAXHandler_startElementNs_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "endElementNs", _wrap__xmlSAXHandler_endElementNs_get, _wrap__xmlSAXHandler_endElementNs_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandler_class, "serror", _wrap__xmlSAXHandler_serror_get, _wrap__xmlSAXHandler_serror_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "internalSubset", _wrap__xmlSAXHandlerV1_internalSubset_get, _wrap__xmlSAXHandlerV1_internalSubset_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "isStandalone", _wrap__xmlSAXHandlerV1_isStandalone_get, _wrap__xmlSAXHandlerV1_isStandalone_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "hasInternalSubset", _wrap__xmlSAXHandlerV1_hasInternalSubset_get, _wrap__xmlSAXHandlerV1_hasInternalSubset_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "hasExternalSubset", _wrap__xmlSAXHandlerV1_hasExternalSubset_get, _wrap__xmlSAXHandlerV1_hasExternalSubset_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "resolveEntity", _wrap__xmlSAXHandlerV1_resolveEntity_get, _wrap__xmlSAXHandlerV1_resolveEntity_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "getEntity", _wrap__xmlSAXHandlerV1_getEntity_get, _wrap__xmlSAXHandlerV1_getEntity_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "entityDecl", _wrap__xmlSAXHandlerV1_entityDecl_get, _wrap__xmlSAXHandlerV1_entityDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "notationDecl", _wrap__xmlSAXHandlerV1_notationDecl_get, _wrap__xmlSAXHandlerV1_notationDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "attributeDecl", _wrap__xmlSAXHandlerV1_attributeDecl_get, _wrap__xmlSAXHandlerV1_attributeDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "elementDecl", _wrap__xmlSAXHandlerV1_elementDecl_get, _wrap__xmlSAXHandlerV1_elementDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "unparsedEntityDecl", _wrap__xmlSAXHandlerV1_unparsedEntityDecl_get, _wrap__xmlSAXHandlerV1_unparsedEntityDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "setDocumentLocator", _wrap__xmlSAXHandlerV1_setDocumentLocator_get, _wrap__xmlSAXHandlerV1_setDocumentLocator_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "startDocument", _wrap__xmlSAXHandlerV1_startDocument_get, _wrap__xmlSAXHandlerV1_startDocument_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "endDocument", _wrap__xmlSAXHandlerV1_endDocument_get, _wrap__xmlSAXHandlerV1_endDocument_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "startElement", _wrap__xmlSAXHandlerV1_startElement_get, _wrap__xmlSAXHandlerV1_startElement_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "endElement", _wrap__xmlSAXHandlerV1_endElement_get, _wrap__xmlSAXHandlerV1_endElement_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "reference", _wrap__xmlSAXHandlerV1_reference_get, _wrap__xmlSAXHandlerV1_reference_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "characters", _wrap__xmlSAXHandlerV1_characters_get, _wrap__xmlSAXHandlerV1_characters_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "ignorableWhitespace", _wrap__xmlSAXHandlerV1_ignorableWhitespace_get, _wrap__xmlSAXHandlerV1_ignorableWhitespace_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "processingInstruction", _wrap__xmlSAXHandlerV1_processingInstruction_get, _wrap__xmlSAXHandlerV1_processingInstruction_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "comment", _wrap__xmlSAXHandlerV1_comment_get, _wrap__xmlSAXHandlerV1_comment_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "warning", _wrap__xmlSAXHandlerV1_warning_get, _wrap__xmlSAXHandlerV1_warning_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "error", _wrap__xmlSAXHandlerV1_error_get, _wrap__xmlSAXHandlerV1_error_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "fatalError", _wrap__xmlSAXHandlerV1_fatalError_get, _wrap__xmlSAXHandlerV1_fatalError_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "getParameterEntity", _wrap__xmlSAXHandlerV1_getParameterEntity_get, _wrap__xmlSAXHandlerV1_getParameterEntity_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "cdataBlock", _wrap__xmlSAXHandlerV1_cdataBlock_get, _wrap__xmlSAXHandlerV1_cdataBlock_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "externalSubset", _wrap__xmlSAXHandlerV1_externalSubset_get, _wrap__xmlSAXHandlerV1_externalSubset_set);
SWIGV8_AddMemberVariable(_exports__xmlSAXHandlerV1_class, "initialized", _wrap__xmlSAXHandlerV1_initialized_get, _wrap__xmlSAXHandlerV1_initialized_set);
SWIGV8_AddStaticVariable(exports_obj, "xmlParserVersion", _wrap_xmlParserVersion_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "oldXMLWDcompatibility", _wrap_oldXMLWDcompatibility_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlParserDebugEntities", _wrap_xmlParserDebugEntities_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlDefaultSAXLocator", _wrap_xmlDefaultSAXLocator_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlDefaultSAXHandler", _wrap_xmlDefaultSAXHandler_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_RECOVER", exports_XML_PARSE_RECOVER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NOENT", exports_XML_PARSE_NOENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_DTDLOAD", exports_XML_PARSE_DTDLOAD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_DTDATTR", exports_XML_PARSE_DTDATTR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_DTDVALID", exports_XML_PARSE_DTDVALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NOERROR", exports_XML_PARSE_NOERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NOWARNING", exports_XML_PARSE_NOWARNING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_PEDANTIC", exports_XML_PARSE_PEDANTIC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NOBLANKS", exports_XML_PARSE_NOBLANKS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_SAX1", exports_XML_PARSE_SAX1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_XINCLUDE", exports_XML_PARSE_XINCLUDE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NONET", exports_XML_PARSE_NONET_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NODICT", exports_XML_PARSE_NODICT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NSCLEAN", exports_XML_PARSE_NSCLEAN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NOCDATA", exports_XML_PARSE_NOCDATA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NOXINCNODE", exports_XML_PARSE_NOXINCNODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_COMPACT", exports_XML_PARSE_COMPACT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_OLD10", exports_XML_PARSE_OLD10_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NOBASEFIX", exports_XML_PARSE_NOBASEFIX_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_HUGE", exports_XML_PARSE_HUGE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_OLDSAX", exports_XML_PARSE_OLDSAX_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_IGNORE_ENC", exports_XML_PARSE_IGNORE_ENC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_BIG_LINES", exports_XML_PARSE_BIG_LINES_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NO_XXE", exports_XML_PARSE_NO_XXE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_THREAD", exports_XML_WITH_THREAD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_TREE", exports_XML_WITH_TREE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_OUTPUT", exports_XML_WITH_OUTPUT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_PUSH", exports_XML_WITH_PUSH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_READER", exports_XML_WITH_READER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_PATTERN", exports_XML_WITH_PATTERN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_WRITER", exports_XML_WITH_WRITER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_SAX1", exports_XML_WITH_SAX1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_FTP", exports_XML_WITH_FTP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_HTTP", exports_XML_WITH_HTTP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_VALID", exports_XML_WITH_VALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_HTML", exports_XML_WITH_HTML_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_LEGACY", exports_XML_WITH_LEGACY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_C14N", exports_XML_WITH_C14N_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_CATALOG", exports_XML_WITH_CATALOG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_XPATH", exports_XML_WITH_XPATH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_XPTR", exports_XML_WITH_XPTR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_XINCLUDE", exports_XML_WITH_XINCLUDE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_ICONV", exports_XML_WITH_ICONV_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_ISO8859X", exports_XML_WITH_ISO8859X_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_UNICODE", exports_XML_WITH_UNICODE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_REGEXP", exports_XML_WITH_REGEXP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_AUTOMATA", exports_XML_WITH_AUTOMATA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_EXPR", exports_XML_WITH_EXPR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_SCHEMAS", exports_XML_WITH_SCHEMAS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_SCHEMATRON", exports_XML_WITH_SCHEMATRON_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_MODULES", exports_XML_WITH_MODULES_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_DEBUG", exports_XML_WITH_DEBUG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_DEBUG_MEM", exports_XML_WITH_DEBUG_MEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_DEBUG_RUN", exports_XML_WITH_DEBUG_RUN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_ZLIB", exports_XML_WITH_ZLIB_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_ICU", exports_XML_WITH_ICU_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_LZMA", exports_XML_WITH_LZMA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_NONE", exports_XML_WITH_NONE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_EXPRESSION_OK", exports_XPATH_EXPRESSION_OK_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_NUMBER_ERROR", exports_XPATH_NUMBER_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_UNFINISHED_LITERAL_ERROR", exports_XPATH_UNFINISHED_LITERAL_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_START_LITERAL_ERROR", exports_XPATH_START_LITERAL_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_VARIABLE_REF_ERROR", exports_XPATH_VARIABLE_REF_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_UNDEF_VARIABLE_ERROR", exports_XPATH_UNDEF_VARIABLE_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_INVALID_PREDICATE_ERROR", exports_XPATH_INVALID_PREDICATE_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_EXPR_ERROR", exports_XPATH_EXPR_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_UNCLOSED_ERROR", exports_XPATH_UNCLOSED_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_UNKNOWN_FUNC_ERROR", exports_XPATH_UNKNOWN_FUNC_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_INVALID_OPERAND", exports_XPATH_INVALID_OPERAND_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_INVALID_TYPE", exports_XPATH_INVALID_TYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_INVALID_ARITY", exports_XPATH_INVALID_ARITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_INVALID_CTXT_SIZE", exports_XPATH_INVALID_CTXT_SIZE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_INVALID_CTXT_POSITION", exports_XPATH_INVALID_CTXT_POSITION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_MEMORY_ERROR", exports_XPATH_MEMORY_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPTR_SYNTAX_ERROR", exports_XPTR_SYNTAX_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPTR_RESOURCE_ERROR", exports_XPTR_RESOURCE_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPTR_SUB_RESOURCE_ERROR", exports_XPTR_SUB_RESOURCE_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_UNDEF_PREFIX_ERROR", exports_XPATH_UNDEF_PREFIX_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_ENCODING_ERROR", exports_XPATH_ENCODING_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_INVALID_CHAR_ERROR", exports_XPATH_INVALID_CHAR_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_INVALID_CTXT", exports_XPATH_INVALID_CTXT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_STACK_ERROR", exports_XPATH_STACK_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_FORBID_VARIABLE_ERROR", exports_XPATH_FORBID_VARIABLE_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_OP_LIMIT_EXCEEDED", exports_XPATH_OP_LIMIT_EXCEEDED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_RECURSION_LIMIT_EXCEEDED", exports_XPATH_RECURSION_LIMIT_EXCEEDED_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlNodeSet_class, "nodeNr", _wrap__xmlNodeSet_nodeNr_get, _wrap__xmlNodeSet_nodeNr_set);
SWIGV8_AddMemberVariable(_exports__xmlNodeSet_class, "nodeMax", _wrap__xmlNodeSet_nodeMax_get, _wrap__xmlNodeSet_nodeMax_set);
SWIGV8_AddMemberVariable(_exports__xmlNodeSet_class, "nodeTab", _wrap__xmlNodeSet_nodeTab_get, _wrap__xmlNodeSet_nodeTab_set);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_UNDEFINED", exports_XPATH_UNDEFINED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_NODESET", exports_XPATH_NODESET_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_BOOLEAN", exports_XPATH_BOOLEAN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_NUMBER", exports_XPATH_NUMBER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_STRING", exports_XPATH_STRING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_USERS", exports_XPATH_USERS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_XSLT_TREE", exports_XPATH_XSLT_TREE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_POINT", exports_XPATH_POINT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_RANGE", exports_XPATH_RANGE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_LOCATIONSET", exports_XPATH_LOCATIONSET_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlXPathObject_class, "type", _wrap__xmlXPathObject_type_get, _wrap__xmlXPathObject_type_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathObject_class, "nodesetval", _wrap__xmlXPathObject_nodesetval_get, _wrap__xmlXPathObject_nodesetval_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathObject_class, "boolval", _wrap__xmlXPathObject_boolval_get, _wrap__xmlXPathObject_boolval_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathObject_class, "floatval", _wrap__xmlXPathObject_floatval_get, _wrap__xmlXPathObject_floatval_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathObject_class, "stringval", _wrap__xmlXPathObject_stringval_get, _wrap__xmlXPathObject_stringval_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathObject_class, "user", _wrap__xmlXPathObject_user_get, _wrap__xmlXPathObject_user_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathObject_class, "index", _wrap__xmlXPathObject_index_get, _wrap__xmlXPathObject_index_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathObject_class, "user2", _wrap__xmlXPathObject_user2_get, _wrap__xmlXPathObject_user2_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathObject_class, "index2", _wrap__xmlXPathObject_index2_get, _wrap__xmlXPathObject_index2_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathType_class, "name", _wrap__xmlXPathType_name_get, _wrap__xmlXPathType_name_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathType_class, "func", _wrap__xmlXPathType_func_get, _wrap__xmlXPathType_func_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathVariable_class, "name", _wrap__xmlXPathVariable_name_get, _wrap__xmlXPathVariable_name_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathVariable_class, "value", _wrap__xmlXPathVariable_value_get, _wrap__xmlXPathVariable_value_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathFunct_class, "name", _wrap__xmlXPathFunct_name_get, _wrap__xmlXPathFunct_name_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathFunct_class, "func", _wrap__xmlXPathFunct_func_get, _wrap__xmlXPathFunct_func_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathAxis_class, "name", _wrap__xmlXPathAxis_name_get, _wrap__xmlXPathAxis_name_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathAxis_class, "func", _wrap__xmlXPathAxis_func_get, _wrap__xmlXPathAxis_func_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_CHECKNS", exports_XML_XPATH_CHECKNS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_NOVAR", exports_XML_XPATH_NOVAR_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "doc", _wrap__xmlXPathContext_doc_get, _wrap__xmlXPathContext_doc_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "node", _wrap__xmlXPathContext_node_get, _wrap__xmlXPathContext_node_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "nb_variables_unused", _wrap__xmlXPathContext_nb_variables_unused_get, _wrap__xmlXPathContext_nb_variables_unused_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "max_variables_unused", _wrap__xmlXPathContext_max_variables_unused_get, _wrap__xmlXPathContext_max_variables_unused_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "varHash", _wrap__xmlXPathContext_varHash_get, _wrap__xmlXPathContext_varHash_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "nb_types", _wrap__xmlXPathContext_nb_types_get, _wrap__xmlXPathContext_nb_types_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "max_types", _wrap__xmlXPathContext_max_types_get, _wrap__xmlXPathContext_max_types_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "types", _wrap__xmlXPathContext_types_get, _wrap__xmlXPathContext_types_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "nb_funcs_unused", _wrap__xmlXPathContext_nb_funcs_unused_get, _wrap__xmlXPathContext_nb_funcs_unused_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "max_funcs_unused", _wrap__xmlXPathContext_max_funcs_unused_get, _wrap__xmlXPathContext_max_funcs_unused_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "funcHash", _wrap__xmlXPathContext_funcHash_get, _wrap__xmlXPathContext_funcHash_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "nb_axis", _wrap__xmlXPathContext_nb_axis_get, _wrap__xmlXPathContext_nb_axis_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "max_axis", _wrap__xmlXPathContext_max_axis_get, _wrap__xmlXPathContext_max_axis_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "axis", _wrap__xmlXPathContext_axis_get, _wrap__xmlXPathContext_axis_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "namespaces", _wrap__xmlXPathContext_namespaces_get, _wrap__xmlXPathContext_namespaces_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "nsNr", _wrap__xmlXPathContext_nsNr_get, _wrap__xmlXPathContext_nsNr_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "user", _wrap__xmlXPathContext_user_get, _wrap__xmlXPathContext_user_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "contextSize", _wrap__xmlXPathContext_contextSize_get, _wrap__xmlXPathContext_contextSize_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "proximityPosition", _wrap__xmlXPathContext_proximityPosition_get, _wrap__xmlXPathContext_proximityPosition_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "xptr", _wrap__xmlXPathContext_xptr_get, _wrap__xmlXPathContext_xptr_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "here", _wrap__xmlXPathContext_here_get, _wrap__xmlXPathContext_here_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "origin", _wrap__xmlXPathContext_origin_get, _wrap__xmlXPathContext_origin_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "nsHash", _wrap__xmlXPathContext_nsHash_get, _wrap__xmlXPathContext_nsHash_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "varLookupFunc", _wrap__xmlXPathContext_varLookupFunc_get, _wrap__xmlXPathContext_varLookupFunc_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "varLookupData", _wrap__xmlXPathContext_varLookupData_get, _wrap__xmlXPathContext_varLookupData_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "extra", _wrap__xmlXPathContext_extra_get, _wrap__xmlXPathContext_extra_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "_function", _wrap__xmlXPathContext__function_get, _wrap__xmlXPathContext__function_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "functionURI", _wrap__xmlXPathContext_functionURI_get, _wrap__xmlXPathContext_functionURI_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "funcLookupFunc", _wrap__xmlXPathContext_funcLookupFunc_get, _wrap__xmlXPathContext_funcLookupFunc_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "funcLookupData", _wrap__xmlXPathContext_funcLookupData_get, _wrap__xmlXPathContext_funcLookupData_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "tmpNsList", _wrap__xmlXPathContext_tmpNsList_get, _wrap__xmlXPathContext_tmpNsList_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "tmpNsNr", _wrap__xmlXPathContext_tmpNsNr_get, _wrap__xmlXPathContext_tmpNsNr_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "userData", _wrap__xmlXPathContext_userData_get, _wrap__xmlXPathContext_userData_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "error", _wrap__xmlXPathContext_error_get, _wrap__xmlXPathContext_error_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "lastError", _wrap__xmlXPathContext_lastError_get, _wrap__xmlXPathContext_lastError_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "debugNode", _wrap__xmlXPathContext_debugNode_get, _wrap__xmlXPathContext_debugNode_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "dict", _wrap__xmlXPathContext_dict_get, _wrap__xmlXPathContext_dict_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "flags", _wrap__xmlXPathContext_flags_get, _wrap__xmlXPathContext_flags_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "cache", _wrap__xmlXPathContext_cache_get, _wrap__xmlXPathContext_cache_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "opLimit", _wrap__xmlXPathContext_opLimit_get, _wrap__xmlXPathContext_opLimit_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "opCount", _wrap__xmlXPathContext_opCount_get, _wrap__xmlXPathContext_opCount_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathContext_class, "depth", _wrap__xmlXPathContext_depth_get, _wrap__xmlXPathContext_depth_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathParserContext_class, "cur", _wrap__xmlXPathParserContext_cur_get, _wrap__xmlXPathParserContext_cur_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathParserContext_class, "base", _wrap__xmlXPathParserContext_base_get, _wrap__xmlXPathParserContext_base_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathParserContext_class, "error", _wrap__xmlXPathParserContext_error_get, _wrap__xmlXPathParserContext_error_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathParserContext_class, "context", _wrap__xmlXPathParserContext_context_get, _wrap__xmlXPathParserContext_context_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathParserContext_class, "value", _wrap__xmlXPathParserContext_value_get, _wrap__xmlXPathParserContext_value_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathParserContext_class, "valueNr", _wrap__xmlXPathParserContext_valueNr_get, _wrap__xmlXPathParserContext_valueNr_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathParserContext_class, "valueMax", _wrap__xmlXPathParserContext_valueMax_get, _wrap__xmlXPathParserContext_valueMax_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathParserContext_class, "valueTab", _wrap__xmlXPathParserContext_valueTab_get, _wrap__xmlXPathParserContext_valueTab_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathParserContext_class, "comp", _wrap__xmlXPathParserContext_comp_get, _wrap__xmlXPathParserContext_comp_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathParserContext_class, "xptr", _wrap__xmlXPathParserContext_xptr_get, _wrap__xmlXPathParserContext_xptr_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathParserContext_class, "ancestor", _wrap__xmlXPathParserContext_ancestor_get, _wrap__xmlXPathParserContext_ancestor_set);
SWIGV8_AddMemberVariable(_exports__xmlXPathParserContext_class, "valueFrame", _wrap__xmlXPathParserContext_valueFrame_get, _wrap__xmlXPathParserContext_valueFrame_set);
SWIGV8_AddStaticVariable(exports_obj, "xmlXPathNAN", _wrap_xmlXPathNAN_get, _wrap_xmlXPathNAN_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlXPathPINF", _wrap_xmlXPathPINF_get, _wrap_xmlXPathPINF_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlXPathNINF", _wrap_xmlXPathNINF_get, _wrap_xmlXPathNINF_set, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATA_PREFER_NONE", exports_XML_CATA_PREFER_NONE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATA_PREFER_PUBLIC", exports_XML_CATA_PREFER_PUBLIC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATA_PREFER_SYSTEM", exports_XML_CATA_PREFER_SYSTEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATA_ALLOW_NONE", exports_XML_CATA_ALLOW_NONE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATA_ALLOW_GLOBAL", exports_XML_CATA_ALLOW_GLOBAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATA_ALLOW_DOCUMENT", exports_XML_CATA_ALLOW_DOCUMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATA_ALLOW_ALL", exports_XML_CATA_ALLOW_ALL_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlChSRange_class, "low", _wrap__xmlChSRange_low_get, _wrap__xmlChSRange_low_set);
SWIGV8_AddMemberVariable(_exports__xmlChSRange_class, "high", _wrap__xmlChSRange_high_get, _wrap__xmlChSRange_high_set);
SWIGV8_AddMemberVariable(_exports__xmlChLRange_class, "low", _wrap__xmlChLRange_low_get, _wrap__xmlChLRange_low_set);
SWIGV8_AddMemberVariable(_exports__xmlChLRange_class, "high", _wrap__xmlChLRange_high_get, _wrap__xmlChLRange_high_set);
SWIGV8_AddMemberVariable(_exports__xmlChRangeGroup_class, "nbShortRange", _wrap__xmlChRangeGroup_nbShortRange_get, _wrap__xmlChRangeGroup_nbShortRange_set);
SWIGV8_AddMemberVariable(_exports__xmlChRangeGroup_class, "nbLongRange", _wrap__xmlChRangeGroup_nbLongRange_get, _wrap__xmlChRangeGroup_nbLongRange_set);
SWIGV8_AddMemberVariable(_exports__xmlChRangeGroup_class, "shortRange", _wrap__xmlChRangeGroup_shortRange_get, _wrap__xmlChRangeGroup_shortRange_set);
SWIGV8_AddMemberVariable(_exports__xmlChRangeGroup_class, "longRange", _wrap__xmlChRangeGroup_longRange_get, _wrap__xmlChRangeGroup_longRange_set);
SWIGV8_AddStaticVariable(exports_obj, "xmlIsBaseCharGroup", _wrap_xmlIsBaseCharGroup_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlIsCharGroup", _wrap_xmlIsCharGroup_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlIsCombiningGroup", _wrap_xmlIsCombiningGroup_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlIsDigitGroup", _wrap_xmlIsDigitGroup_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlIsExtenderGroup", _wrap_xmlIsExtenderGroup_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlIsIdeographicGroup", _wrap_xmlIsIdeographicGroup_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlIsPubidChar_tab", _wrap_xmlIsPubidChar_tab_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__htmlElemDesc_class, "name", _wrap__htmlElemDesc_name_get, _wrap__htmlElemDesc_name_set);
SWIGV8_AddMemberVariable(_exports__htmlElemDesc_class, "startTag", _wrap__htmlElemDesc_startTag_get, _wrap__htmlElemDesc_startTag_set);
SWIGV8_AddMemberVariable(_exports__htmlElemDesc_class, "endTag", _wrap__htmlElemDesc_endTag_get, _wrap__htmlElemDesc_endTag_set);
SWIGV8_AddMemberVariable(_exports__htmlElemDesc_class, "saveEndTag", _wrap__htmlElemDesc_saveEndTag_get, _wrap__htmlElemDesc_saveEndTag_set);
SWIGV8_AddMemberVariable(_exports__htmlElemDesc_class, "empty", _wrap__htmlElemDesc_empty_get, _wrap__htmlElemDesc_empty_set);
SWIGV8_AddMemberVariable(_exports__htmlElemDesc_class, "depr", _wrap__htmlElemDesc_depr_get, _wrap__htmlElemDesc_depr_set);
SWIGV8_AddMemberVariable(_exports__htmlElemDesc_class, "dtd", _wrap__htmlElemDesc_dtd_get, _wrap__htmlElemDesc_dtd_set);
SWIGV8_AddMemberVariable(_exports__htmlElemDesc_class, "isinline", _wrap__htmlElemDesc_isinline_get, _wrap__htmlElemDesc_isinline_set);
SWIGV8_AddMemberVariable(_exports__htmlElemDesc_class, "desc", _wrap__htmlElemDesc_desc_get, _wrap__htmlElemDesc_desc_set);
SWIGV8_AddMemberVariable(_exports__htmlElemDesc_class, "subelts", _wrap__htmlElemDesc_subelts_get, _wrap__htmlElemDesc_subelts_set);
SWIGV8_AddMemberVariable(_exports__htmlElemDesc_class, "defaultsubelt", _wrap__htmlElemDesc_defaultsubelt_get, _wrap__htmlElemDesc_defaultsubelt_set);
SWIGV8_AddMemberVariable(_exports__htmlElemDesc_class, "attrs_opt", _wrap__htmlElemDesc_attrs_opt_get, _wrap__htmlElemDesc_attrs_opt_set);
SWIGV8_AddMemberVariable(_exports__htmlElemDesc_class, "attrs_depr", _wrap__htmlElemDesc_attrs_depr_get, _wrap__htmlElemDesc_attrs_depr_set);
SWIGV8_AddMemberVariable(_exports__htmlElemDesc_class, "attrs_req", _wrap__htmlElemDesc_attrs_req_get, _wrap__htmlElemDesc_attrs_req_set);
SWIGV8_AddMemberVariable(_exports__htmlEntityDesc_class, "value", _wrap__htmlEntityDesc_value_get, _wrap__htmlEntityDesc_value_set);
SWIGV8_AddMemberVariable(_exports__htmlEntityDesc_class, "name", _wrap__htmlEntityDesc_name_get, _wrap__htmlEntityDesc_name_set);
SWIGV8_AddMemberVariable(_exports__htmlEntityDesc_class, "desc", _wrap__htmlEntityDesc_desc_get, _wrap__htmlEntityDesc_desc_set);
SWIGV8_AddStaticVariable(exports_obj, "htmlDefaultSAXHandler", _wrap_htmlDefaultSAXHandler_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_RECOVER", exports_HTML_PARSE_RECOVER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_NODEFDTD", exports_HTML_PARSE_NODEFDTD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_NOERROR", exports_HTML_PARSE_NOERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_NOWARNING", exports_HTML_PARSE_NOWARNING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_PEDANTIC", exports_HTML_PARSE_PEDANTIC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_NOBLANKS", exports_HTML_PARSE_NOBLANKS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_NONET", exports_HTML_PARSE_NONET_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_NOIMPLIED", exports_HTML_PARSE_NOIMPLIED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_COMPACT", exports_HTML_PARSE_COMPACT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_IGNORE_ENC", exports_HTML_PARSE_IGNORE_ENC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_NA", exports_HTML_NA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_INVALID", exports_HTML_INVALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_DEPRECATED", exports_HTML_DEPRECATED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_VALID", exports_HTML_VALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_REQUIRED", exports_HTML_REQUIRED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_FORMAT", exports_XML_SAVE_FORMAT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_NO_DECL", exports_XML_SAVE_NO_DECL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_NO_EMPTY", exports_XML_SAVE_NO_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_NO_XHTML", exports_XML_SAVE_NO_XHTML_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_XHTML", exports_XML_SAVE_XHTML_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_AS_XML", exports_XML_SAVE_AS_XML_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_AS_HTML", exports_XML_SAVE_AS_HTML_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_WSNONSIG", exports_XML_SAVE_WSNONSIG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlParserMaxDepth", _wrap_xmlParserMaxDepth_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_MAX_TEXT_LENGTH", exports_XML_MAX_TEXT_LENGTH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_MAX_HUGE_LENGTH", exports_XML_MAX_HUGE_LENGTH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_MAX_NAME_LENGTH", exports_XML_MAX_NAME_LENGTH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_MAX_DICTIONARY_LIMIT", exports_XML_MAX_DICTIONARY_LIMIT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_MAX_LOOKUP_LIMIT", exports_XML_MAX_LOOKUP_LIMIT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_MAX_NAMELEN", exports_XML_MAX_NAMELEN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "INPUT_CHUNK", exports_INPUT_CHUNK_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlStringText", _wrap_xmlStringText_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlStringTextNoenc", _wrap_xmlStringTextNoenc_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlStringComment", _wrap_xmlStringComment_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SUBSTITUTE_NONE", exports_XML_SUBSTITUTE_NONE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SUBSTITUTE_REF", exports_XML_SUBSTITUTE_REF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SUBSTITUTE_PEREF", exports_XML_SUBSTITUTE_PEREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SUBSTITUTE_BOTH", exports_XML_SUBSTITUTE_BOTH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PATTERN_DEFAULT", exports_XML_PATTERN_DEFAULT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PATTERN_XPATH", exports_XML_PATTERN_XPATH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PATTERN_XSSEL", exports_XML_PATTERN_XSSEL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PATTERN_XSFIELD", exports_XML_PATTERN_XSFIELD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_OK", exports_XML_RELAXNG_OK_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_MEMORY", exports_XML_RELAXNG_ERR_MEMORY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_TYPE", exports_XML_RELAXNG_ERR_TYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_TYPEVAL", exports_XML_RELAXNG_ERR_TYPEVAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_DUPID", exports_XML_RELAXNG_ERR_DUPID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_TYPECMP", exports_XML_RELAXNG_ERR_TYPECMP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_NOSTATE", exports_XML_RELAXNG_ERR_NOSTATE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_NODEFINE", exports_XML_RELAXNG_ERR_NODEFINE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_LISTEXTRA", exports_XML_RELAXNG_ERR_LISTEXTRA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_LISTEMPTY", exports_XML_RELAXNG_ERR_LISTEMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_INTERNODATA", exports_XML_RELAXNG_ERR_INTERNODATA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_INTERSEQ", exports_XML_RELAXNG_ERR_INTERSEQ_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_INTEREXTRA", exports_XML_RELAXNG_ERR_INTEREXTRA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ELEMNAME", exports_XML_RELAXNG_ERR_ELEMNAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ATTRNAME", exports_XML_RELAXNG_ERR_ATTRNAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ELEMNONS", exports_XML_RELAXNG_ERR_ELEMNONS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ATTRNONS", exports_XML_RELAXNG_ERR_ATTRNONS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ELEMWRONGNS", exports_XML_RELAXNG_ERR_ELEMWRONGNS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ATTRWRONGNS", exports_XML_RELAXNG_ERR_ATTRWRONGNS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ELEMEXTRANS", exports_XML_RELAXNG_ERR_ELEMEXTRANS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ATTREXTRANS", exports_XML_RELAXNG_ERR_ATTREXTRANS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ELEMNOTEMPTY", exports_XML_RELAXNG_ERR_ELEMNOTEMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_NOELEM", exports_XML_RELAXNG_ERR_NOELEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_NOTELEM", exports_XML_RELAXNG_ERR_NOTELEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ATTRVALID", exports_XML_RELAXNG_ERR_ATTRVALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_CONTENTVALID", exports_XML_RELAXNG_ERR_CONTENTVALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_EXTRACONTENT", exports_XML_RELAXNG_ERR_EXTRACONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_INVALIDATTR", exports_XML_RELAXNG_ERR_INVALIDATTR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_DATAELEM", exports_XML_RELAXNG_ERR_DATAELEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_VALELEM", exports_XML_RELAXNG_ERR_VALELEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_LISTELEM", exports_XML_RELAXNG_ERR_LISTELEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_DATATYPE", exports_XML_RELAXNG_ERR_DATATYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_VALUE", exports_XML_RELAXNG_ERR_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_LIST", exports_XML_RELAXNG_ERR_LIST_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_NOGRAMMAR", exports_XML_RELAXNG_ERR_NOGRAMMAR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_EXTRADATA", exports_XML_RELAXNG_ERR_EXTRADATA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_LACKDATA", exports_XML_RELAXNG_ERR_LACKDATA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_INTERNAL", exports_XML_RELAXNG_ERR_INTERNAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ELEMWRONG", exports_XML_RELAXNG_ERR_ELEMWRONG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_TEXTWRONG", exports_XML_RELAXNG_ERR_TEXTWRONG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNGP_NONE", exports_XML_RELAXNGP_NONE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNGP_FREE_DOC", exports_XML_RELAXNGP_FREE_DOC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNGP_CRNG", exports_XML_RELAXNGP_CRNG_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlURI_class, "scheme", _wrap__xmlURI_scheme_get, _wrap__xmlURI_scheme_set);
SWIGV8_AddMemberVariable(_exports__xmlURI_class, "opaque", _wrap__xmlURI_opaque_get, _wrap__xmlURI_opaque_set);
SWIGV8_AddMemberVariable(_exports__xmlURI_class, "authority", _wrap__xmlURI_authority_get, _wrap__xmlURI_authority_set);
SWIGV8_AddMemberVariable(_exports__xmlURI_class, "server", _wrap__xmlURI_server_get, _wrap__xmlURI_server_set);
SWIGV8_AddMemberVariable(_exports__xmlURI_class, "user", _wrap__xmlURI_user_get, _wrap__xmlURI_user_set);
SWIGV8_AddMemberVariable(_exports__xmlURI_class, "port", _wrap__xmlURI_port_get, _wrap__xmlURI_port_set);
SWIGV8_AddMemberVariable(_exports__xmlURI_class, "path", _wrap__xmlURI_path_get, _wrap__xmlURI_path_set);
SWIGV8_AddMemberVariable(_exports__xmlURI_class, "query", _wrap__xmlURI_query_get, _wrap__xmlURI_query_set);
SWIGV8_AddMemberVariable(_exports__xmlURI_class, "fragment", _wrap__xmlURI_fragment_get, _wrap__xmlURI_fragment_set);
SWIGV8_AddMemberVariable(_exports__xmlURI_class, "cleanup", _wrap__xmlURI_cleanup_get, _wrap__xmlURI_cleanup_set);
SWIGV8_AddMemberVariable(_exports__xmlURI_class, "query_raw", _wrap__xmlURI_query_raw_get, _wrap__xmlURI_query_raw_set);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_TYPE_NONE", exports_XLINK_TYPE_NONE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_TYPE_SIMPLE", exports_XLINK_TYPE_SIMPLE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_TYPE_EXTENDED", exports_XLINK_TYPE_EXTENDED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_TYPE_EXTENDED_SET", exports_XLINK_TYPE_EXTENDED_SET_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_SHOW_NONE", exports_XLINK_SHOW_NONE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_SHOW_NEW", exports_XLINK_SHOW_NEW_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_SHOW_EMBED", exports_XLINK_SHOW_EMBED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_SHOW_REPLACE", exports_XLINK_SHOW_REPLACE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_ACTUATE_NONE", exports_XLINK_ACTUATE_NONE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_ACTUATE_AUTO", exports_XLINK_ACTUATE_AUTO_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_ACTUATE_ONREQUEST", exports_XLINK_ACTUATE_ONREQUEST_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xlinkHandler_class, "simple", _wrap__xlinkHandler_simple_get, _wrap__xlinkHandler_simple_set);
SWIGV8_AddMemberVariable(_exports__xlinkHandler_class, "extended", _wrap__xlinkHandler_extended_get, _wrap__xlinkHandler_extended_set);
SWIGV8_AddMemberVariable(_exports__xlinkHandler_class, "set", _wrap__xlinkHandler_set_get, _wrap__xlinkHandler_set_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_MODULE_LAZY", exports_XML_MODULE_LAZY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_MODULE_LOCAL", exports_XML_MODULE_LOCAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_OK", exports_XML_SCHEMAS_ERR_OK_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_NOROOT", exports_XML_SCHEMAS_ERR_NOROOT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_UNDECLAREDELEM", exports_XML_SCHEMAS_ERR_UNDECLAREDELEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_NOTTOPLEVEL", exports_XML_SCHEMAS_ERR_NOTTOPLEVEL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_MISSING", exports_XML_SCHEMAS_ERR_MISSING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_WRONGELEM", exports_XML_SCHEMAS_ERR_WRONGELEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_NOTYPE", exports_XML_SCHEMAS_ERR_NOTYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_NOROLLBACK", exports_XML_SCHEMAS_ERR_NOROLLBACK_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_ISABSTRACT", exports_XML_SCHEMAS_ERR_ISABSTRACT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_NOTEMPTY", exports_XML_SCHEMAS_ERR_NOTEMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_ELEMCONT", exports_XML_SCHEMAS_ERR_ELEMCONT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_HAVEDEFAULT", exports_XML_SCHEMAS_ERR_HAVEDEFAULT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_NOTNILLABLE", exports_XML_SCHEMAS_ERR_NOTNILLABLE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_EXTRACONTENT", exports_XML_SCHEMAS_ERR_EXTRACONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_INVALIDATTR", exports_XML_SCHEMAS_ERR_INVALIDATTR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_INVALIDELEM", exports_XML_SCHEMAS_ERR_INVALIDELEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_NOTDETERMINIST", exports_XML_SCHEMAS_ERR_NOTDETERMINIST_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_CONSTRUCT", exports_XML_SCHEMAS_ERR_CONSTRUCT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_INTERNAL", exports_XML_SCHEMAS_ERR_INTERNAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_NOTSIMPLE", exports_XML_SCHEMAS_ERR_NOTSIMPLE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_ATTRUNKNOWN", exports_XML_SCHEMAS_ERR_ATTRUNKNOWN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_ATTRINVALID", exports_XML_SCHEMAS_ERR_ATTRINVALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_VALUE", exports_XML_SCHEMAS_ERR_VALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_FACET", exports_XML_SCHEMAS_ERR_FACET_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_", exports_XML_SCHEMAS_ERR__get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_XXX", exports_XML_SCHEMAS_ERR_XXX_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_VAL_VC_I_CREATE", exports_XML_SCHEMA_VAL_VC_I_CREATE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_SEVERITY_VALIDITY_WARNING", exports_XML_PARSER_SEVERITY_VALIDITY_WARNING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_SEVERITY_VALIDITY_ERROR", exports_XML_PARSER_SEVERITY_VALIDITY_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_SEVERITY_WARNING", exports_XML_PARSER_SEVERITY_WARNING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_SEVERITY_ERROR", exports_XML_PARSER_SEVERITY_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_TEXTREADER_MODE_INITIAL", exports_XML_TEXTREADER_MODE_INITIAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_TEXTREADER_MODE_INTERACTIVE", exports_XML_TEXTREADER_MODE_INTERACTIVE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_TEXTREADER_MODE_ERROR", exports_XML_TEXTREADER_MODE_ERROR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_TEXTREADER_MODE_EOF", exports_XML_TEXTREADER_MODE_EOF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_TEXTREADER_MODE_CLOSED", exports_XML_TEXTREADER_MODE_CLOSED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_TEXTREADER_MODE_READING", exports_XML_TEXTREADER_MODE_READING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_LOADDTD", exports_XML_PARSER_LOADDTD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_DEFAULTATTRS", exports_XML_PARSER_DEFAULTATTRS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_VALIDATE", exports_XML_PARSER_VALIDATE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_SUBST_ENTITIES", exports_XML_PARSER_SUBST_ENTITIES_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_NONE", exports_XML_READER_TYPE_NONE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_ELEMENT", exports_XML_READER_TYPE_ELEMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_ATTRIBUTE", exports_XML_READER_TYPE_ATTRIBUTE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_TEXT", exports_XML_READER_TYPE_TEXT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_CDATA", exports_XML_READER_TYPE_CDATA_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_ENTITY_REFERENCE", exports_XML_READER_TYPE_ENTITY_REFERENCE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_ENTITY", exports_XML_READER_TYPE_ENTITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_PROCESSING_INSTRUCTION", exports_XML_READER_TYPE_PROCESSING_INSTRUCTION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_COMMENT", exports_XML_READER_TYPE_COMMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_DOCUMENT", exports_XML_READER_TYPE_DOCUMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_DOCUMENT_TYPE", exports_XML_READER_TYPE_DOCUMENT_TYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_DOCUMENT_FRAGMENT", exports_XML_READER_TYPE_DOCUMENT_FRAGMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_NOTATION", exports_XML_READER_TYPE_NOTATION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_WHITESPACE", exports_XML_READER_TYPE_WHITESPACE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_SIGNIFICANT_WHITESPACE", exports_XML_READER_TYPE_SIGNIFICANT_WHITESPACE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_END_ELEMENT", exports_XML_READER_TYPE_END_ELEMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_END_ENTITY", exports_XML_READER_TYPE_END_ENTITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_READER_TYPE_XML_DECLARATION", exports_XML_READER_TYPE_XML_DECLARATION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_UNKNOWN", exports_XML_SCHEMAS_UNKNOWN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_STRING", exports_XML_SCHEMAS_STRING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NORMSTRING", exports_XML_SCHEMAS_NORMSTRING_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_DECIMAL", exports_XML_SCHEMAS_DECIMAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TIME", exports_XML_SCHEMAS_TIME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_GDAY", exports_XML_SCHEMAS_GDAY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_GMONTH", exports_XML_SCHEMAS_GMONTH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_GMONTHDAY", exports_XML_SCHEMAS_GMONTHDAY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_GYEAR", exports_XML_SCHEMAS_GYEAR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_GYEARMONTH", exports_XML_SCHEMAS_GYEARMONTH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_DATE", exports_XML_SCHEMAS_DATE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_DATETIME", exports_XML_SCHEMAS_DATETIME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_DURATION", exports_XML_SCHEMAS_DURATION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_FLOAT", exports_XML_SCHEMAS_FLOAT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_DOUBLE", exports_XML_SCHEMAS_DOUBLE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_BOOLEAN", exports_XML_SCHEMAS_BOOLEAN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TOKEN", exports_XML_SCHEMAS_TOKEN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_LANGUAGE", exports_XML_SCHEMAS_LANGUAGE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NMTOKEN", exports_XML_SCHEMAS_NMTOKEN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NMTOKENS", exports_XML_SCHEMAS_NMTOKENS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NAME", exports_XML_SCHEMAS_NAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_QNAME", exports_XML_SCHEMAS_QNAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NCNAME", exports_XML_SCHEMAS_NCNAME_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ID", exports_XML_SCHEMAS_ID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_IDREF", exports_XML_SCHEMAS_IDREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_IDREFS", exports_XML_SCHEMAS_IDREFS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ENTITY", exports_XML_SCHEMAS_ENTITY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ENTITIES", exports_XML_SCHEMAS_ENTITIES_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NOTATION", exports_XML_SCHEMAS_NOTATION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ANYURI", exports_XML_SCHEMAS_ANYURI_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_INTEGER", exports_XML_SCHEMAS_INTEGER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NPINTEGER", exports_XML_SCHEMAS_NPINTEGER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NINTEGER", exports_XML_SCHEMAS_NINTEGER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NNINTEGER", exports_XML_SCHEMAS_NNINTEGER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_PINTEGER", exports_XML_SCHEMAS_PINTEGER_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_INT", exports_XML_SCHEMAS_INT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_UINT", exports_XML_SCHEMAS_UINT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_LONG", exports_XML_SCHEMAS_LONG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ULONG", exports_XML_SCHEMAS_ULONG_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_SHORT", exports_XML_SCHEMAS_SHORT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_USHORT", exports_XML_SCHEMAS_USHORT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_BYTE", exports_XML_SCHEMAS_BYTE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_UBYTE", exports_XML_SCHEMAS_UBYTE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_HEXBINARY", exports_XML_SCHEMAS_HEXBINARY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_BASE64BINARY", exports_XML_SCHEMAS_BASE64BINARY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ANYTYPE", exports_XML_SCHEMAS_ANYTYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ANYSIMPLETYPE", exports_XML_SCHEMAS_ANYSIMPLETYPE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_BASIC", exports_XML_SCHEMA_TYPE_BASIC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_ANY", exports_XML_SCHEMA_TYPE_ANY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_FACET", exports_XML_SCHEMA_TYPE_FACET_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_SIMPLE", exports_XML_SCHEMA_TYPE_SIMPLE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_COMPLEX", exports_XML_SCHEMA_TYPE_COMPLEX_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_SEQUENCE", exports_XML_SCHEMA_TYPE_SEQUENCE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_CHOICE", exports_XML_SCHEMA_TYPE_CHOICE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_ALL", exports_XML_SCHEMA_TYPE_ALL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_SIMPLE_CONTENT", exports_XML_SCHEMA_TYPE_SIMPLE_CONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_COMPLEX_CONTENT", exports_XML_SCHEMA_TYPE_COMPLEX_CONTENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_UR", exports_XML_SCHEMA_TYPE_UR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_RESTRICTION", exports_XML_SCHEMA_TYPE_RESTRICTION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_EXTENSION", exports_XML_SCHEMA_TYPE_EXTENSION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_ELEMENT", exports_XML_SCHEMA_TYPE_ELEMENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_ATTRIBUTE", exports_XML_SCHEMA_TYPE_ATTRIBUTE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_ATTRIBUTEGROUP", exports_XML_SCHEMA_TYPE_ATTRIBUTEGROUP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_GROUP", exports_XML_SCHEMA_TYPE_GROUP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_NOTATION", exports_XML_SCHEMA_TYPE_NOTATION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_LIST", exports_XML_SCHEMA_TYPE_LIST_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_UNION", exports_XML_SCHEMA_TYPE_UNION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_ANY_ATTRIBUTE", exports_XML_SCHEMA_TYPE_ANY_ATTRIBUTE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_IDC_UNIQUE", exports_XML_SCHEMA_TYPE_IDC_UNIQUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_IDC_KEY", exports_XML_SCHEMA_TYPE_IDC_KEY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_IDC_KEYREF", exports_XML_SCHEMA_TYPE_IDC_KEYREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_PARTICLE", exports_XML_SCHEMA_TYPE_PARTICLE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_ATTRIBUTE_USE", exports_XML_SCHEMA_TYPE_ATTRIBUTE_USE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_MININCLUSIVE", exports_XML_SCHEMA_FACET_MININCLUSIVE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_MINEXCLUSIVE", exports_XML_SCHEMA_FACET_MINEXCLUSIVE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_MAXINCLUSIVE", exports_XML_SCHEMA_FACET_MAXINCLUSIVE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_MAXEXCLUSIVE", exports_XML_SCHEMA_FACET_MAXEXCLUSIVE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_TOTALDIGITS", exports_XML_SCHEMA_FACET_TOTALDIGITS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_FRACTIONDIGITS", exports_XML_SCHEMA_FACET_FRACTIONDIGITS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_PATTERN", exports_XML_SCHEMA_FACET_PATTERN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_ENUMERATION", exports_XML_SCHEMA_FACET_ENUMERATION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_WHITESPACE", exports_XML_SCHEMA_FACET_WHITESPACE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_LENGTH", exports_XML_SCHEMA_FACET_LENGTH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_MAXLENGTH", exports_XML_SCHEMA_FACET_MAXLENGTH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_MINLENGTH", exports_XML_SCHEMA_FACET_MINLENGTH_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_EXTRA_QNAMEREF", exports_XML_SCHEMA_EXTRA_QNAMEREF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_EXTRA_ATTR_USE_PROHIB", exports_XML_SCHEMA_EXTRA_ATTR_USE_PROHIB_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_CONTENT_UNKNOWN", exports_XML_SCHEMA_CONTENT_UNKNOWN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_CONTENT_EMPTY", exports_XML_SCHEMA_CONTENT_EMPTY_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_CONTENT_ELEMENTS", exports_XML_SCHEMA_CONTENT_ELEMENTS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_CONTENT_MIXED", exports_XML_SCHEMA_CONTENT_MIXED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_CONTENT_SIMPLE", exports_XML_SCHEMA_CONTENT_SIMPLE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS", exports_XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_CONTENT_BASIC", exports_XML_SCHEMA_CONTENT_BASIC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_CONTENT_ANY", exports_XML_SCHEMA_CONTENT_ANY_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAnnot_class, "next", _wrap__xmlSchemaAnnot_next_get, _wrap__xmlSchemaAnnot_next_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAnnot_class, "content", _wrap__xmlSchemaAnnot_content_get, _wrap__xmlSchemaAnnot_content_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ANYATTR_SKIP", exports_XML_SCHEMAS_ANYATTR_SKIP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ANYATTR_LAX", exports_XML_SCHEMAS_ANYATTR_LAX_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ANYATTR_STRICT", exports_XML_SCHEMAS_ANYATTR_STRICT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ANY_SKIP", exports_XML_SCHEMAS_ANY_SKIP_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ANY_LAX", exports_XML_SCHEMAS_ANY_LAX_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ANY_STRICT", exports_XML_SCHEMAS_ANY_STRICT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTR_USE_PROHIBITED", exports_XML_SCHEMAS_ATTR_USE_PROHIBITED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTR_USE_REQUIRED", exports_XML_SCHEMAS_ATTR_USE_REQUIRED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTR_USE_OPTIONAL", exports_XML_SCHEMAS_ATTR_USE_OPTIONAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTR_GLOBAL", exports_XML_SCHEMAS_ATTR_GLOBAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTR_NSDEFAULT", exports_XML_SCHEMAS_ATTR_NSDEFAULT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTR_INTERNAL_RESOLVED", exports_XML_SCHEMAS_ATTR_INTERNAL_RESOLVED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTR_FIXED", exports_XML_SCHEMAS_ATTR_FIXED_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "type", _wrap__xmlSchemaAttribute_type_get, _wrap__xmlSchemaAttribute_type_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "next", _wrap__xmlSchemaAttribute_next_get, _wrap__xmlSchemaAttribute_next_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "name", _wrap__xmlSchemaAttribute_name_get, _wrap__xmlSchemaAttribute_name_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "id", _wrap__xmlSchemaAttribute_id_get, _wrap__xmlSchemaAttribute_id_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "ref", _wrap__xmlSchemaAttribute_ref_get, _wrap__xmlSchemaAttribute_ref_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "refNs", _wrap__xmlSchemaAttribute_refNs_get, _wrap__xmlSchemaAttribute_refNs_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "typeName", _wrap__xmlSchemaAttribute_typeName_get, _wrap__xmlSchemaAttribute_typeName_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "typeNs", _wrap__xmlSchemaAttribute_typeNs_get, _wrap__xmlSchemaAttribute_typeNs_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "annot", _wrap__xmlSchemaAttribute_annot_get, _wrap__xmlSchemaAttribute_annot_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "base", _wrap__xmlSchemaAttribute_base_get, _wrap__xmlSchemaAttribute_base_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "occurs", _wrap__xmlSchemaAttribute_occurs_get, _wrap__xmlSchemaAttribute_occurs_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "defValue", _wrap__xmlSchemaAttribute_defValue_get, _wrap__xmlSchemaAttribute_defValue_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "subtypes", _wrap__xmlSchemaAttribute_subtypes_get, _wrap__xmlSchemaAttribute_subtypes_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "node", _wrap__xmlSchemaAttribute_node_get, _wrap__xmlSchemaAttribute_node_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "targetNamespace", _wrap__xmlSchemaAttribute_targetNamespace_get, _wrap__xmlSchemaAttribute_targetNamespace_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "flags", _wrap__xmlSchemaAttribute_flags_get, _wrap__xmlSchemaAttribute_flags_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "refPrefix", _wrap__xmlSchemaAttribute_refPrefix_get, _wrap__xmlSchemaAttribute_refPrefix_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "defVal", _wrap__xmlSchemaAttribute_defVal_get, _wrap__xmlSchemaAttribute_defVal_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttribute_class, "refDecl", _wrap__xmlSchemaAttribute_refDecl_get, _wrap__xmlSchemaAttribute_refDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttributeLink_class, "next", _wrap__xmlSchemaAttributeLink_next_get, _wrap__xmlSchemaAttributeLink_next_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttributeLink_class, "attr", _wrap__xmlSchemaAttributeLink_attr_get, _wrap__xmlSchemaAttributeLink_attr_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_WILDCARD_COMPLETE", exports_XML_SCHEMAS_WILDCARD_COMPLETE_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlSchemaWildcardNs_class, "next", _wrap__xmlSchemaWildcardNs_next_get, _wrap__xmlSchemaWildcardNs_next_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaWildcardNs_class, "value", _wrap__xmlSchemaWildcardNs_value_get, _wrap__xmlSchemaWildcardNs_value_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaWildcard_class, "type", _wrap__xmlSchemaWildcard_type_get, _wrap__xmlSchemaWildcard_type_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaWildcard_class, "id", _wrap__xmlSchemaWildcard_id_get, _wrap__xmlSchemaWildcard_id_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaWildcard_class, "annot", _wrap__xmlSchemaWildcard_annot_get, _wrap__xmlSchemaWildcard_annot_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaWildcard_class, "node", _wrap__xmlSchemaWildcard_node_get, _wrap__xmlSchemaWildcard_node_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaWildcard_class, "minOccurs", _wrap__xmlSchemaWildcard_minOccurs_get, _wrap__xmlSchemaWildcard_minOccurs_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaWildcard_class, "maxOccurs", _wrap__xmlSchemaWildcard_maxOccurs_get, _wrap__xmlSchemaWildcard_maxOccurs_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaWildcard_class, "processContents", _wrap__xmlSchemaWildcard_processContents_get, _wrap__xmlSchemaWildcard_processContents_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaWildcard_class, "any", _wrap__xmlSchemaWildcard_any_get, _wrap__xmlSchemaWildcard_any_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaWildcard_class, "nsSet", _wrap__xmlSchemaWildcard_nsSet_get, _wrap__xmlSchemaWildcard_nsSet_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaWildcard_class, "negNsSet", _wrap__xmlSchemaWildcard_negNsSet_get, _wrap__xmlSchemaWildcard_negNsSet_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaWildcard_class, "flags", _wrap__xmlSchemaWildcard_flags_get, _wrap__xmlSchemaWildcard_flags_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED", exports_XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTRGROUP_GLOBAL", exports_XML_SCHEMAS_ATTRGROUP_GLOBAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTRGROUP_MARKED", exports_XML_SCHEMAS_ATTRGROUP_MARKED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTRGROUP_REDEFINED", exports_XML_SCHEMAS_ATTRGROUP_REDEFINED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTRGROUP_HAS_REFS", exports_XML_SCHEMAS_ATTRGROUP_HAS_REFS_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttributeGroup_class, "type", _wrap__xmlSchemaAttributeGroup_type_get, _wrap__xmlSchemaAttributeGroup_type_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttributeGroup_class, "next", _wrap__xmlSchemaAttributeGroup_next_get, _wrap__xmlSchemaAttributeGroup_next_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttributeGroup_class, "name", _wrap__xmlSchemaAttributeGroup_name_get, _wrap__xmlSchemaAttributeGroup_name_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttributeGroup_class, "id", _wrap__xmlSchemaAttributeGroup_id_get, _wrap__xmlSchemaAttributeGroup_id_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttributeGroup_class, "ref", _wrap__xmlSchemaAttributeGroup_ref_get, _wrap__xmlSchemaAttributeGroup_ref_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttributeGroup_class, "refNs", _wrap__xmlSchemaAttributeGroup_refNs_get, _wrap__xmlSchemaAttributeGroup_refNs_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttributeGroup_class, "annot", _wrap__xmlSchemaAttributeGroup_annot_get, _wrap__xmlSchemaAttributeGroup_annot_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttributeGroup_class, "attributes", _wrap__xmlSchemaAttributeGroup_attributes_get, _wrap__xmlSchemaAttributeGroup_attributes_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttributeGroup_class, "node", _wrap__xmlSchemaAttributeGroup_node_get, _wrap__xmlSchemaAttributeGroup_node_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttributeGroup_class, "flags", _wrap__xmlSchemaAttributeGroup_flags_get, _wrap__xmlSchemaAttributeGroup_flags_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttributeGroup_class, "attributeWildcard", _wrap__xmlSchemaAttributeGroup_attributeWildcard_get, _wrap__xmlSchemaAttributeGroup_attributeWildcard_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttributeGroup_class, "refPrefix", _wrap__xmlSchemaAttributeGroup_refPrefix_get, _wrap__xmlSchemaAttributeGroup_refPrefix_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttributeGroup_class, "refItem", _wrap__xmlSchemaAttributeGroup_refItem_get, _wrap__xmlSchemaAttributeGroup_refItem_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttributeGroup_class, "targetNamespace", _wrap__xmlSchemaAttributeGroup_targetNamespace_get, _wrap__xmlSchemaAttributeGroup_targetNamespace_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaAttributeGroup_class, "attrUses", _wrap__xmlSchemaAttributeGroup_attrUses_get, _wrap__xmlSchemaAttributeGroup_attrUses_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaTypeLink_class, "next", _wrap__xmlSchemaTypeLink_next_get, _wrap__xmlSchemaTypeLink_next_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaTypeLink_class, "type", _wrap__xmlSchemaTypeLink_type_get, _wrap__xmlSchemaTypeLink_type_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaFacetLink_class, "next", _wrap__xmlSchemaFacetLink_next_get, _wrap__xmlSchemaFacetLink_next_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaFacetLink_class, "facet", _wrap__xmlSchemaFacetLink_facet_get, _wrap__xmlSchemaFacetLink_facet_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_MIXED", exports_XML_SCHEMAS_TYPE_MIXED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION", exports_XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION", exports_XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_GLOBAL", exports_XML_SCHEMAS_TYPE_GLOBAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD", exports_XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_VARIETY_ABSENT", exports_XML_SCHEMAS_TYPE_VARIETY_ABSENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_VARIETY_LIST", exports_XML_SCHEMAS_TYPE_VARIETY_LIST_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_VARIETY_UNION", exports_XML_SCHEMAS_TYPE_VARIETY_UNION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_VARIETY_ATOMIC", exports_XML_SCHEMAS_TYPE_VARIETY_ATOMIC_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_FINAL_EXTENSION", exports_XML_SCHEMAS_TYPE_FINAL_EXTENSION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_FINAL_RESTRICTION", exports_XML_SCHEMAS_TYPE_FINAL_RESTRICTION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_FINAL_LIST", exports_XML_SCHEMAS_TYPE_FINAL_LIST_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_FINAL_UNION", exports_XML_SCHEMAS_TYPE_FINAL_UNION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_FINAL_DEFAULT", exports_XML_SCHEMAS_TYPE_FINAL_DEFAULT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE", exports_XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_MARKED", exports_XML_SCHEMAS_TYPE_MARKED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_BLOCK_DEFAULT", exports_XML_SCHEMAS_TYPE_BLOCK_DEFAULT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_BLOCK_EXTENSION", exports_XML_SCHEMAS_TYPE_BLOCK_EXTENSION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_BLOCK_RESTRICTION", exports_XML_SCHEMAS_TYPE_BLOCK_RESTRICTION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_ABSTRACT", exports_XML_SCHEMAS_TYPE_ABSTRACT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_FACETSNEEDVALUE", exports_XML_SCHEMAS_TYPE_FACETSNEEDVALUE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_INTERNAL_RESOLVED", exports_XML_SCHEMAS_TYPE_INTERNAL_RESOLVED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_INTERNAL_INVALID", exports_XML_SCHEMAS_TYPE_INTERNAL_INVALID_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE", exports_XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_WHITESPACE_REPLACE", exports_XML_SCHEMAS_TYPE_WHITESPACE_REPLACE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE", exports_XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_HAS_FACETS", exports_XML_SCHEMAS_TYPE_HAS_FACETS_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_NORMVALUENEEDED", exports_XML_SCHEMAS_TYPE_NORMVALUENEEDED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_FIXUP_1", exports_XML_SCHEMAS_TYPE_FIXUP_1_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_REDEFINED", exports_XML_SCHEMAS_TYPE_REDEFINED_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "type", _wrap__xmlSchemaType_type_get, _wrap__xmlSchemaType_type_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "next", _wrap__xmlSchemaType_next_get, _wrap__xmlSchemaType_next_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "name", _wrap__xmlSchemaType_name_get, _wrap__xmlSchemaType_name_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "id", _wrap__xmlSchemaType_id_get, _wrap__xmlSchemaType_id_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "ref", _wrap__xmlSchemaType_ref_get, _wrap__xmlSchemaType_ref_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "refNs", _wrap__xmlSchemaType_refNs_get, _wrap__xmlSchemaType_refNs_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "annot", _wrap__xmlSchemaType_annot_get, _wrap__xmlSchemaType_annot_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "subtypes", _wrap__xmlSchemaType_subtypes_get, _wrap__xmlSchemaType_subtypes_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "attributes", _wrap__xmlSchemaType_attributes_get, _wrap__xmlSchemaType_attributes_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "node", _wrap__xmlSchemaType_node_get, _wrap__xmlSchemaType_node_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "minOccurs", _wrap__xmlSchemaType_minOccurs_get, _wrap__xmlSchemaType_minOccurs_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "maxOccurs", _wrap__xmlSchemaType_maxOccurs_get, _wrap__xmlSchemaType_maxOccurs_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "flags", _wrap__xmlSchemaType_flags_get, _wrap__xmlSchemaType_flags_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "contentType", _wrap__xmlSchemaType_contentType_get, _wrap__xmlSchemaType_contentType_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "base", _wrap__xmlSchemaType_base_get, _wrap__xmlSchemaType_base_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "baseNs", _wrap__xmlSchemaType_baseNs_get, _wrap__xmlSchemaType_baseNs_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "baseType", _wrap__xmlSchemaType_baseType_get, _wrap__xmlSchemaType_baseType_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "facets", _wrap__xmlSchemaType_facets_get, _wrap__xmlSchemaType_facets_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "redef", _wrap__xmlSchemaType_redef_get, _wrap__xmlSchemaType_redef_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "recurse", _wrap__xmlSchemaType_recurse_get, _wrap__xmlSchemaType_recurse_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "attributeUses", _wrap__xmlSchemaType_attributeUses_get, _wrap__xmlSchemaType_attributeUses_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "attributeWildcard", _wrap__xmlSchemaType_attributeWildcard_get, _wrap__xmlSchemaType_attributeWildcard_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "builtInType", _wrap__xmlSchemaType_builtInType_get, _wrap__xmlSchemaType_builtInType_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "memberTypes", _wrap__xmlSchemaType_memberTypes_get, _wrap__xmlSchemaType_memberTypes_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "facetSet", _wrap__xmlSchemaType_facetSet_get, _wrap__xmlSchemaType_facetSet_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "refPrefix", _wrap__xmlSchemaType_refPrefix_get, _wrap__xmlSchemaType_refPrefix_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "contentTypeDef", _wrap__xmlSchemaType_contentTypeDef_get, _wrap__xmlSchemaType_contentTypeDef_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "contModel", _wrap__xmlSchemaType_contModel_get, _wrap__xmlSchemaType_contModel_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "targetNamespace", _wrap__xmlSchemaType_targetNamespace_get, _wrap__xmlSchemaType_targetNamespace_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaType_class, "attrUses", _wrap__xmlSchemaType_attrUses_get, _wrap__xmlSchemaType_attrUses_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_NILLABLE", exports_XML_SCHEMAS_ELEM_NILLABLE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_GLOBAL", exports_XML_SCHEMAS_ELEM_GLOBAL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_DEFAULT", exports_XML_SCHEMAS_ELEM_DEFAULT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_FIXED", exports_XML_SCHEMAS_ELEM_FIXED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_ABSTRACT", exports_XML_SCHEMAS_ELEM_ABSTRACT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_TOPLEVEL", exports_XML_SCHEMAS_ELEM_TOPLEVEL_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_REF", exports_XML_SCHEMAS_ELEM_REF_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_NSDEFAULT", exports_XML_SCHEMAS_ELEM_NSDEFAULT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_INTERNAL_RESOLVED", exports_XML_SCHEMAS_ELEM_INTERNAL_RESOLVED_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_CIRCULAR", exports_XML_SCHEMAS_ELEM_CIRCULAR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_BLOCK_ABSENT", exports_XML_SCHEMAS_ELEM_BLOCK_ABSENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_BLOCK_EXTENSION", exports_XML_SCHEMAS_ELEM_BLOCK_EXTENSION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_BLOCK_RESTRICTION", exports_XML_SCHEMAS_ELEM_BLOCK_RESTRICTION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION", exports_XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_FINAL_ABSENT", exports_XML_SCHEMAS_ELEM_FINAL_ABSENT_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_FINAL_EXTENSION", exports_XML_SCHEMAS_ELEM_FINAL_EXTENSION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_FINAL_RESTRICTION", exports_XML_SCHEMAS_ELEM_FINAL_RESTRICTION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD", exports_XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_INTERNAL_CHECKED", exports_XML_SCHEMAS_ELEM_INTERNAL_CHECKED_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "type", _wrap__xmlSchemaElement_type_get, _wrap__xmlSchemaElement_type_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "next", _wrap__xmlSchemaElement_next_get, _wrap__xmlSchemaElement_next_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "name", _wrap__xmlSchemaElement_name_get, _wrap__xmlSchemaElement_name_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "id", _wrap__xmlSchemaElement_id_get, _wrap__xmlSchemaElement_id_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "ref", _wrap__xmlSchemaElement_ref_get, _wrap__xmlSchemaElement_ref_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "refNs", _wrap__xmlSchemaElement_refNs_get, _wrap__xmlSchemaElement_refNs_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "annot", _wrap__xmlSchemaElement_annot_get, _wrap__xmlSchemaElement_annot_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "subtypes", _wrap__xmlSchemaElement_subtypes_get, _wrap__xmlSchemaElement_subtypes_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "attributes", _wrap__xmlSchemaElement_attributes_get, _wrap__xmlSchemaElement_attributes_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "node", _wrap__xmlSchemaElement_node_get, _wrap__xmlSchemaElement_node_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "minOccurs", _wrap__xmlSchemaElement_minOccurs_get, _wrap__xmlSchemaElement_minOccurs_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "maxOccurs", _wrap__xmlSchemaElement_maxOccurs_get, _wrap__xmlSchemaElement_maxOccurs_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "flags", _wrap__xmlSchemaElement_flags_get, _wrap__xmlSchemaElement_flags_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "targetNamespace", _wrap__xmlSchemaElement_targetNamespace_get, _wrap__xmlSchemaElement_targetNamespace_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "namedType", _wrap__xmlSchemaElement_namedType_get, _wrap__xmlSchemaElement_namedType_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "namedTypeNs", _wrap__xmlSchemaElement_namedTypeNs_get, _wrap__xmlSchemaElement_namedTypeNs_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "substGroup", _wrap__xmlSchemaElement_substGroup_get, _wrap__xmlSchemaElement_substGroup_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "substGroupNs", _wrap__xmlSchemaElement_substGroupNs_get, _wrap__xmlSchemaElement_substGroupNs_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "scope", _wrap__xmlSchemaElement_scope_get, _wrap__xmlSchemaElement_scope_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "value", _wrap__xmlSchemaElement_value_get, _wrap__xmlSchemaElement_value_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "refDecl", _wrap__xmlSchemaElement_refDecl_get, _wrap__xmlSchemaElement_refDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "contModel", _wrap__xmlSchemaElement_contModel_get, _wrap__xmlSchemaElement_contModel_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "contentType", _wrap__xmlSchemaElement_contentType_get, _wrap__xmlSchemaElement_contentType_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "refPrefix", _wrap__xmlSchemaElement_refPrefix_get, _wrap__xmlSchemaElement_refPrefix_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "defVal", _wrap__xmlSchemaElement_defVal_get, _wrap__xmlSchemaElement_defVal_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaElement_class, "idcs", _wrap__xmlSchemaElement_idcs_get, _wrap__xmlSchemaElement_idcs_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_FACET_UNKNOWN", exports_XML_SCHEMAS_FACET_UNKNOWN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_FACET_PRESERVE", exports_XML_SCHEMAS_FACET_PRESERVE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_FACET_REPLACE", exports_XML_SCHEMAS_FACET_REPLACE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_FACET_COLLAPSE", exports_XML_SCHEMAS_FACET_COLLAPSE_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlSchemaFacet_class, "type", _wrap__xmlSchemaFacet_type_get, _wrap__xmlSchemaFacet_type_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaFacet_class, "next", _wrap__xmlSchemaFacet_next_get, _wrap__xmlSchemaFacet_next_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaFacet_class, "value", _wrap__xmlSchemaFacet_value_get, _wrap__xmlSchemaFacet_value_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaFacet_class, "id", _wrap__xmlSchemaFacet_id_get, _wrap__xmlSchemaFacet_id_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaFacet_class, "annot", _wrap__xmlSchemaFacet_annot_get, _wrap__xmlSchemaFacet_annot_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaFacet_class, "node", _wrap__xmlSchemaFacet_node_get, _wrap__xmlSchemaFacet_node_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaFacet_class, "fixed", _wrap__xmlSchemaFacet_fixed_get, _wrap__xmlSchemaFacet_fixed_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaFacet_class, "whitespace", _wrap__xmlSchemaFacet_whitespace_get, _wrap__xmlSchemaFacet_whitespace_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaFacet_class, "val", _wrap__xmlSchemaFacet_val_get, _wrap__xmlSchemaFacet_val_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaFacet_class, "regexp", _wrap__xmlSchemaFacet_regexp_get, _wrap__xmlSchemaFacet_regexp_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaNotation_class, "type", _wrap__xmlSchemaNotation_type_get, _wrap__xmlSchemaNotation_type_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaNotation_class, "name", _wrap__xmlSchemaNotation_name_get, _wrap__xmlSchemaNotation_name_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaNotation_class, "annot", _wrap__xmlSchemaNotation_annot_get, _wrap__xmlSchemaNotation_annot_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaNotation_class, "identifier", _wrap__xmlSchemaNotation_identifier_get, _wrap__xmlSchemaNotation_identifier_set);
SWIGV8_AddMemberVariable(_exports__xmlSchemaNotation_class, "targetNamespace", _wrap__xmlSchemaNotation_targetNamespace_get, _wrap__xmlSchemaNotation_targetNamespace_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_QUALIF_ELEM", exports_XML_SCHEMAS_QUALIF_ELEM_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_QUALIF_ATTR", exports_XML_SCHEMAS_QUALIF_ATTR_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_FINAL_DEFAULT_EXTENSION", exports_XML_SCHEMAS_FINAL_DEFAULT_EXTENSION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION", exports_XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_FINAL_DEFAULT_LIST", exports_XML_SCHEMAS_FINAL_DEFAULT_LIST_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_FINAL_DEFAULT_UNION", exports_XML_SCHEMAS_FINAL_DEFAULT_UNION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION", exports_XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION", exports_XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION", exports_XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_INCLUDING_CONVERT_NS", exports_XML_SCHEMAS_INCLUDING_CONVERT_NS_get, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "name", _wrap__xmlSchema_name_get, _wrap__xmlSchema_name_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "targetNamespace", _wrap__xmlSchema_targetNamespace_get, _wrap__xmlSchema_targetNamespace_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "version", _wrap__xmlSchema_version_get, _wrap__xmlSchema_version_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "id", _wrap__xmlSchema_id_get, _wrap__xmlSchema_id_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "doc", _wrap__xmlSchema_doc_get, _wrap__xmlSchema_doc_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "annot", _wrap__xmlSchema_annot_get, _wrap__xmlSchema_annot_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "flags", _wrap__xmlSchema_flags_get, _wrap__xmlSchema_flags_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "typeDecl", _wrap__xmlSchema_typeDecl_get, _wrap__xmlSchema_typeDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "attrDecl", _wrap__xmlSchema_attrDecl_get, _wrap__xmlSchema_attrDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "attrgrpDecl", _wrap__xmlSchema_attrgrpDecl_get, _wrap__xmlSchema_attrgrpDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "elemDecl", _wrap__xmlSchema_elemDecl_get, _wrap__xmlSchema_elemDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "notaDecl", _wrap__xmlSchema_notaDecl_get, _wrap__xmlSchema_notaDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "schemasImports", _wrap__xmlSchema_schemasImports_get, _wrap__xmlSchema_schemasImports_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "_private", _wrap__xmlSchema__private_get, _wrap__xmlSchema__private_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "groupDecl", _wrap__xmlSchema_groupDecl_get, _wrap__xmlSchema_groupDecl_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "dict", _wrap__xmlSchema_dict_get, _wrap__xmlSchema_dict_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "includes", _wrap__xmlSchema_includes_get, _wrap__xmlSchema_includes_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "preserve", _wrap__xmlSchema_preserve_get, _wrap__xmlSchema_preserve_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "counter", _wrap__xmlSchema_counter_get, _wrap__xmlSchema_counter_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "idcDef", _wrap__xmlSchema_idcDef_get, _wrap__xmlSchema_idcDef_set);
SWIGV8_AddMemberVariable(_exports__xmlSchema_class, "volatiles", _wrap__xmlSchema_volatiles_get, _wrap__xmlSchema_volatiles_set);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_WHITESPACE_UNKNOWN", exports_XML_SCHEMA_WHITESPACE_UNKNOWN_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_WHITESPACE_PRESERVE", exports_XML_SCHEMA_WHITESPACE_PRESERVE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_WHITESPACE_REPLACE", exports_XML_SCHEMA_WHITESPACE_REPLACE_get, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_WHITESPACE_COLLAPSE", exports_XML_SCHEMA_WHITESPACE_COLLAPSE_get, JS_veto_set_variable, context);


  /* setup inheritances */
  

  /* class instances */
  /* Class: _xmlBuffer (_exports__xmlBuffer) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlBuffer_class_0 = SWIGV8_CreateClassTemplate("_xmlBuffer");
_exports__xmlBuffer_class_0->SetCallHandler(_wrap_new__xmlBuffer);
_exports__xmlBuffer_class_0->Inherit(_exports__xmlBuffer_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlBuffer_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlBuffer_obj = _exports__xmlBuffer_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlBuffer_obj = _exports__xmlBuffer_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlNotation (_exports__xmlNotation) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlNotation_class_0 = SWIGV8_CreateClassTemplate("_xmlNotation");
_exports__xmlNotation_class_0->SetCallHandler(_wrap_new__xmlNotation);
_exports__xmlNotation_class_0->Inherit(_exports__xmlNotation_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlNotation_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlNotation_obj = _exports__xmlNotation_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlNotation_obj = _exports__xmlNotation_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlEnumeration (_exports__xmlEnumeration) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlEnumeration_class_0 = SWIGV8_CreateClassTemplate("_xmlEnumeration");
_exports__xmlEnumeration_class_0->SetCallHandler(_wrap_new__xmlEnumeration);
_exports__xmlEnumeration_class_0->Inherit(_exports__xmlEnumeration_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlEnumeration_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlEnumeration_obj = _exports__xmlEnumeration_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlEnumeration_obj = _exports__xmlEnumeration_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlAttribute (_exports__xmlAttribute) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlAttribute_class_0 = SWIGV8_CreateClassTemplate("_xmlAttribute");
_exports__xmlAttribute_class_0->SetCallHandler(_wrap_new__xmlAttribute);
_exports__xmlAttribute_class_0->Inherit(_exports__xmlAttribute_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlAttribute_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlAttribute_obj = _exports__xmlAttribute_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlAttribute_obj = _exports__xmlAttribute_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlElementContent (_exports__xmlElementContent) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlElementContent_class_0 = SWIGV8_CreateClassTemplate("_xmlElementContent");
_exports__xmlElementContent_class_0->SetCallHandler(_wrap_new__xmlElementContent);
_exports__xmlElementContent_class_0->Inherit(_exports__xmlElementContent_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlElementContent_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlElementContent_obj = _exports__xmlElementContent_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlElementContent_obj = _exports__xmlElementContent_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlElement (_exports__xmlElement) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlElement_class_0 = SWIGV8_CreateClassTemplate("_xmlElement");
_exports__xmlElement_class_0->SetCallHandler(_wrap_new__xmlElement);
_exports__xmlElement_class_0->Inherit(_exports__xmlElement_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlElement_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlElement_obj = _exports__xmlElement_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlElement_obj = _exports__xmlElement_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlNs (_exports__xmlNs) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlNs_class_0 = SWIGV8_CreateClassTemplate("_xmlNs");
_exports__xmlNs_class_0->SetCallHandler(_wrap_new__xmlNs);
_exports__xmlNs_class_0->Inherit(_exports__xmlNs_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlNs_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlNs_obj = _exports__xmlNs_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlNs_obj = _exports__xmlNs_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlDtd (_exports__xmlDtd) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlDtd_class_0 = SWIGV8_CreateClassTemplate("_xmlDtd");
_exports__xmlDtd_class_0->SetCallHandler(_wrap_new__xmlDtd);
_exports__xmlDtd_class_0->Inherit(_exports__xmlDtd_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlDtd_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlDtd_obj = _exports__xmlDtd_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlDtd_obj = _exports__xmlDtd_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlAttr (_exports__xmlAttr) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlAttr_class_0 = SWIGV8_CreateClassTemplate("_xmlAttr");
_exports__xmlAttr_class_0->SetCallHandler(_wrap_new__xmlAttr);
_exports__xmlAttr_class_0->Inherit(_exports__xmlAttr_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlAttr_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlAttr_obj = _exports__xmlAttr_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlAttr_obj = _exports__xmlAttr_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlID (_exports__xmlID) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlID_class_0 = SWIGV8_CreateClassTemplate("_xmlID");
_exports__xmlID_class_0->SetCallHandler(_wrap_new__xmlID);
_exports__xmlID_class_0->Inherit(_exports__xmlID_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlID_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlID_obj = _exports__xmlID_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlID_obj = _exports__xmlID_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlRef (_exports__xmlRef) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlRef_class_0 = SWIGV8_CreateClassTemplate("_xmlRef");
_exports__xmlRef_class_0->SetCallHandler(_wrap_new__xmlRef);
_exports__xmlRef_class_0->Inherit(_exports__xmlRef_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlRef_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlRef_obj = _exports__xmlRef_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlRef_obj = _exports__xmlRef_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlNode (_exports__xmlNode) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlNode_class_0 = SWIGV8_CreateClassTemplate("_xmlNode");
_exports__xmlNode_class_0->SetCallHandler(_wrap_new__xmlNode);
_exports__xmlNode_class_0->Inherit(_exports__xmlNode_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlNode_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlNode_obj = _exports__xmlNode_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlNode_obj = _exports__xmlNode_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlDoc (_exports__xmlDoc) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlDoc_class_0 = SWIGV8_CreateClassTemplate("_xmlDoc");
_exports__xmlDoc_class_0->SetCallHandler(_wrap_new__xmlDoc);
_exports__xmlDoc_class_0->Inherit(_exports__xmlDoc_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlDoc_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlDoc_obj = _exports__xmlDoc_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlDoc_obj = _exports__xmlDoc_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlDOMWrapCtxt (_exports__xmlDOMWrapCtxt) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlDOMWrapCtxt_class_0 = SWIGV8_CreateClassTemplate("_xmlDOMWrapCtxt");
_exports__xmlDOMWrapCtxt_class_0->SetCallHandler(_wrap_new__xmlDOMWrapCtxt);
_exports__xmlDOMWrapCtxt_class_0->Inherit(_exports__xmlDOMWrapCtxt_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlDOMWrapCtxt_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlDOMWrapCtxt_obj = _exports__xmlDOMWrapCtxt_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlDOMWrapCtxt_obj = _exports__xmlDOMWrapCtxt_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlError (_exports__xmlError) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlError_class_0 = SWIGV8_CreateClassTemplate("_xmlError");
_exports__xmlError_class_0->SetCallHandler(_wrap_new__xmlError);
_exports__xmlError_class_0->Inherit(_exports__xmlError_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlError_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlError_obj = _exports__xmlError_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlError_obj = _exports__xmlError_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlValidCtxt (_exports__xmlValidCtxt) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlValidCtxt_class_0 = SWIGV8_CreateClassTemplate("_xmlValidCtxt");
_exports__xmlValidCtxt_class_0->SetCallHandler(_wrap_new__xmlValidCtxt);
_exports__xmlValidCtxt_class_0->Inherit(_exports__xmlValidCtxt_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlValidCtxt_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlValidCtxt_obj = _exports__xmlValidCtxt_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlValidCtxt_obj = _exports__xmlValidCtxt_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlEntity (_exports__xmlEntity) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlEntity_class_0 = SWIGV8_CreateClassTemplate("_xmlEntity");
_exports__xmlEntity_class_0->SetCallHandler(_wrap_new__xmlEntity);
_exports__xmlEntity_class_0->Inherit(_exports__xmlEntity_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlEntity_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlEntity_obj = _exports__xmlEntity_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlEntity_obj = _exports__xmlEntity_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlCharEncodingHandler (_exports__xmlCharEncodingHandler) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlCharEncodingHandler_class_0 = SWIGV8_CreateClassTemplate("_xmlCharEncodingHandler");
_exports__xmlCharEncodingHandler_class_0->SetCallHandler(_wrap_new__xmlCharEncodingHandler);
_exports__xmlCharEncodingHandler_class_0->Inherit(_exports__xmlCharEncodingHandler_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlCharEncodingHandler_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlCharEncodingHandler_obj = _exports__xmlCharEncodingHandler_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlCharEncodingHandler_obj = _exports__xmlCharEncodingHandler_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlParserInputBuffer (_exports__xmlParserInputBuffer) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlParserInputBuffer_class_0 = SWIGV8_CreateClassTemplate("_xmlParserInputBuffer");
_exports__xmlParserInputBuffer_class_0->SetCallHandler(_wrap_new__xmlParserInputBuffer);
_exports__xmlParserInputBuffer_class_0->Inherit(_exports__xmlParserInputBuffer_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlParserInputBuffer_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlParserInputBuffer_obj = _exports__xmlParserInputBuffer_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlParserInputBuffer_obj = _exports__xmlParserInputBuffer_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlOutputBuffer (_exports__xmlOutputBuffer) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlOutputBuffer_class_0 = SWIGV8_CreateClassTemplate("_xmlOutputBuffer");
_exports__xmlOutputBuffer_class_0->SetCallHandler(_wrap_new__xmlOutputBuffer);
_exports__xmlOutputBuffer_class_0->Inherit(_exports__xmlOutputBuffer_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlOutputBuffer_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlOutputBuffer_obj = _exports__xmlOutputBuffer_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlOutputBuffer_obj = _exports__xmlOutputBuffer_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlParserInput (_exports__xmlParserInput) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlParserInput_class_0 = SWIGV8_CreateClassTemplate("_xmlParserInput");
_exports__xmlParserInput_class_0->SetCallHandler(_wrap_new__xmlParserInput);
_exports__xmlParserInput_class_0->Inherit(_exports__xmlParserInput_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlParserInput_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlParserInput_obj = _exports__xmlParserInput_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlParserInput_obj = _exports__xmlParserInput_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlParserNodeInfo (_exports__xmlParserNodeInfo) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlParserNodeInfo_class_0 = SWIGV8_CreateClassTemplate("_xmlParserNodeInfo");
_exports__xmlParserNodeInfo_class_0->SetCallHandler(_wrap_new__xmlParserNodeInfo);
_exports__xmlParserNodeInfo_class_0->Inherit(_exports__xmlParserNodeInfo_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlParserNodeInfo_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlParserNodeInfo_obj = _exports__xmlParserNodeInfo_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlParserNodeInfo_obj = _exports__xmlParserNodeInfo_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlParserNodeInfoSeq (_exports__xmlParserNodeInfoSeq) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlParserNodeInfoSeq_class_0 = SWIGV8_CreateClassTemplate("_xmlParserNodeInfoSeq");
_exports__xmlParserNodeInfoSeq_class_0->SetCallHandler(_wrap_new__xmlParserNodeInfoSeq);
_exports__xmlParserNodeInfoSeq_class_0->Inherit(_exports__xmlParserNodeInfoSeq_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlParserNodeInfoSeq_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlParserNodeInfoSeq_obj = _exports__xmlParserNodeInfoSeq_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlParserNodeInfoSeq_obj = _exports__xmlParserNodeInfoSeq_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlParserCtxt (_exports__xmlParserCtxt) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlParserCtxt_class_0 = SWIGV8_CreateClassTemplate("_xmlParserCtxt");
_exports__xmlParserCtxt_class_0->SetCallHandler(_wrap_new__xmlParserCtxt);
_exports__xmlParserCtxt_class_0->Inherit(_exports__xmlParserCtxt_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlParserCtxt_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlParserCtxt_obj = _exports__xmlParserCtxt_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlParserCtxt_obj = _exports__xmlParserCtxt_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlSAXLocator (_exports__xmlSAXLocator) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSAXLocator_class_0 = SWIGV8_CreateClassTemplate("_xmlSAXLocator");
_exports__xmlSAXLocator_class_0->SetCallHandler(_wrap_new__xmlSAXLocator);
_exports__xmlSAXLocator_class_0->Inherit(_exports__xmlSAXLocator_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlSAXLocator_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlSAXLocator_obj = _exports__xmlSAXLocator_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlSAXLocator_obj = _exports__xmlSAXLocator_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlSAXHandler (_exports__xmlSAXHandler) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSAXHandler_class_0 = SWIGV8_CreateClassTemplate("_xmlSAXHandler");
_exports__xmlSAXHandler_class_0->SetCallHandler(_wrap_new__xmlSAXHandler);
_exports__xmlSAXHandler_class_0->Inherit(_exports__xmlSAXHandler_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlSAXHandler_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlSAXHandler_obj = _exports__xmlSAXHandler_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlSAXHandler_obj = _exports__xmlSAXHandler_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlSAXHandlerV1 (_exports__xmlSAXHandlerV1) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSAXHandlerV1_class_0 = SWIGV8_CreateClassTemplate("_xmlSAXHandlerV1");
_exports__xmlSAXHandlerV1_class_0->SetCallHandler(_wrap_new__xmlSAXHandlerV1);
_exports__xmlSAXHandlerV1_class_0->Inherit(_exports__xmlSAXHandlerV1_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlSAXHandlerV1_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlSAXHandlerV1_obj = _exports__xmlSAXHandlerV1_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlSAXHandlerV1_obj = _exports__xmlSAXHandlerV1_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlNodeSet (_exports__xmlNodeSet) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlNodeSet_class_0 = SWIGV8_CreateClassTemplate("_xmlNodeSet");
_exports__xmlNodeSet_class_0->SetCallHandler(_wrap_new__xmlNodeSet);
_exports__xmlNodeSet_class_0->Inherit(_exports__xmlNodeSet_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlNodeSet_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlNodeSet_obj = _exports__xmlNodeSet_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlNodeSet_obj = _exports__xmlNodeSet_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlXPathObject (_exports__xmlXPathObject) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlXPathObject_class_0 = SWIGV8_CreateClassTemplate("_xmlXPathObject");
_exports__xmlXPathObject_class_0->SetCallHandler(_wrap_new__xmlXPathObject);
_exports__xmlXPathObject_class_0->Inherit(_exports__xmlXPathObject_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlXPathObject_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlXPathObject_obj = _exports__xmlXPathObject_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlXPathObject_obj = _exports__xmlXPathObject_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlXPathType (_exports__xmlXPathType) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlXPathType_class_0 = SWIGV8_CreateClassTemplate("_xmlXPathType");
_exports__xmlXPathType_class_0->SetCallHandler(_wrap_new__xmlXPathType);
_exports__xmlXPathType_class_0->Inherit(_exports__xmlXPathType_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlXPathType_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlXPathType_obj = _exports__xmlXPathType_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlXPathType_obj = _exports__xmlXPathType_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlXPathVariable (_exports__xmlXPathVariable) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlXPathVariable_class_0 = SWIGV8_CreateClassTemplate("_xmlXPathVariable");
_exports__xmlXPathVariable_class_0->SetCallHandler(_wrap_new__xmlXPathVariable);
_exports__xmlXPathVariable_class_0->Inherit(_exports__xmlXPathVariable_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlXPathVariable_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlXPathVariable_obj = _exports__xmlXPathVariable_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlXPathVariable_obj = _exports__xmlXPathVariable_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlXPathFunct (_exports__xmlXPathFunct) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlXPathFunct_class_0 = SWIGV8_CreateClassTemplate("_xmlXPathFunct");
_exports__xmlXPathFunct_class_0->SetCallHandler(_wrap_new__xmlXPathFunct);
_exports__xmlXPathFunct_class_0->Inherit(_exports__xmlXPathFunct_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlXPathFunct_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlXPathFunct_obj = _exports__xmlXPathFunct_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlXPathFunct_obj = _exports__xmlXPathFunct_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlXPathAxis (_exports__xmlXPathAxis) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlXPathAxis_class_0 = SWIGV8_CreateClassTemplate("_xmlXPathAxis");
_exports__xmlXPathAxis_class_0->SetCallHandler(_wrap_new__xmlXPathAxis);
_exports__xmlXPathAxis_class_0->Inherit(_exports__xmlXPathAxis_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlXPathAxis_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlXPathAxis_obj = _exports__xmlXPathAxis_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlXPathAxis_obj = _exports__xmlXPathAxis_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlXPathContext (_exports__xmlXPathContext) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlXPathContext_class_0 = SWIGV8_CreateClassTemplate("_xmlXPathContext");
_exports__xmlXPathContext_class_0->SetCallHandler(_wrap_new__xmlXPathContext);
_exports__xmlXPathContext_class_0->Inherit(_exports__xmlXPathContext_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlXPathContext_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlXPathContext_obj = _exports__xmlXPathContext_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlXPathContext_obj = _exports__xmlXPathContext_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlXPathParserContext (_exports__xmlXPathParserContext) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlXPathParserContext_class_0 = SWIGV8_CreateClassTemplate("_xmlXPathParserContext");
_exports__xmlXPathParserContext_class_0->SetCallHandler(_wrap_new__xmlXPathParserContext);
_exports__xmlXPathParserContext_class_0->Inherit(_exports__xmlXPathParserContext_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlXPathParserContext_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlXPathParserContext_obj = _exports__xmlXPathParserContext_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlXPathParserContext_obj = _exports__xmlXPathParserContext_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlChSRange (_exports__xmlChSRange) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlChSRange_class_0 = SWIGV8_CreateClassTemplate("_xmlChSRange");
_exports__xmlChSRange_class_0->SetCallHandler(_wrap_new__xmlChSRange);
_exports__xmlChSRange_class_0->Inherit(_exports__xmlChSRange_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlChSRange_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlChSRange_obj = _exports__xmlChSRange_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlChSRange_obj = _exports__xmlChSRange_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlChLRange (_exports__xmlChLRange) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlChLRange_class_0 = SWIGV8_CreateClassTemplate("_xmlChLRange");
_exports__xmlChLRange_class_0->SetCallHandler(_wrap_new__xmlChLRange);
_exports__xmlChLRange_class_0->Inherit(_exports__xmlChLRange_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlChLRange_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlChLRange_obj = _exports__xmlChLRange_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlChLRange_obj = _exports__xmlChLRange_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlChRangeGroup (_exports__xmlChRangeGroup) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlChRangeGroup_class_0 = SWIGV8_CreateClassTemplate("_xmlChRangeGroup");
_exports__xmlChRangeGroup_class_0->SetCallHandler(_wrap_new__xmlChRangeGroup);
_exports__xmlChRangeGroup_class_0->Inherit(_exports__xmlChRangeGroup_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlChRangeGroup_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlChRangeGroup_obj = _exports__xmlChRangeGroup_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlChRangeGroup_obj = _exports__xmlChRangeGroup_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _htmlElemDesc (_exports__htmlElemDesc) */
SWIGV8_FUNCTION_TEMPLATE _exports__htmlElemDesc_class_0 = SWIGV8_CreateClassTemplate("_htmlElemDesc");
_exports__htmlElemDesc_class_0->SetCallHandler(_wrap_new__htmlElemDesc);
_exports__htmlElemDesc_class_0->Inherit(_exports__htmlElemDesc_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__htmlElemDesc_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__htmlElemDesc_obj = _exports__htmlElemDesc_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__htmlElemDesc_obj = _exports__htmlElemDesc_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _htmlEntityDesc (_exports__htmlEntityDesc) */
SWIGV8_FUNCTION_TEMPLATE _exports__htmlEntityDesc_class_0 = SWIGV8_CreateClassTemplate("_htmlEntityDesc");
_exports__htmlEntityDesc_class_0->SetCallHandler(_wrap_new__htmlEntityDesc);
_exports__htmlEntityDesc_class_0->Inherit(_exports__htmlEntityDesc_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__htmlEntityDesc_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__htmlEntityDesc_obj = _exports__htmlEntityDesc_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__htmlEntityDesc_obj = _exports__htmlEntityDesc_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlURI (_exports__xmlURI) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlURI_class_0 = SWIGV8_CreateClassTemplate("_xmlURI");
_exports__xmlURI_class_0->SetCallHandler(_wrap_new__xmlURI);
_exports__xmlURI_class_0->Inherit(_exports__xmlURI_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlURI_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlURI_obj = _exports__xmlURI_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlURI_obj = _exports__xmlURI_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xlinkHandler (_exports__xlinkHandler) */
SWIGV8_FUNCTION_TEMPLATE _exports__xlinkHandler_class_0 = SWIGV8_CreateClassTemplate("_xlinkHandler");
_exports__xlinkHandler_class_0->SetCallHandler(_wrap_new__xlinkHandler);
_exports__xlinkHandler_class_0->Inherit(_exports__xlinkHandler_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xlinkHandler_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xlinkHandler_obj = _exports__xlinkHandler_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xlinkHandler_obj = _exports__xlinkHandler_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlSchemaAnnot (_exports__xmlSchemaAnnot) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaAnnot_class_0 = SWIGV8_CreateClassTemplate("_xmlSchemaAnnot");
_exports__xmlSchemaAnnot_class_0->SetCallHandler(_wrap_new__xmlSchemaAnnot);
_exports__xmlSchemaAnnot_class_0->Inherit(_exports__xmlSchemaAnnot_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlSchemaAnnot_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlSchemaAnnot_obj = _exports__xmlSchemaAnnot_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlSchemaAnnot_obj = _exports__xmlSchemaAnnot_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlSchemaAttribute (_exports__xmlSchemaAttribute) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaAttribute_class_0 = SWIGV8_CreateClassTemplate("_xmlSchemaAttribute");
_exports__xmlSchemaAttribute_class_0->SetCallHandler(_wrap_new__xmlSchemaAttribute);
_exports__xmlSchemaAttribute_class_0->Inherit(_exports__xmlSchemaAttribute_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlSchemaAttribute_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlSchemaAttribute_obj = _exports__xmlSchemaAttribute_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlSchemaAttribute_obj = _exports__xmlSchemaAttribute_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlSchemaAttributeLink (_exports__xmlSchemaAttributeLink) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaAttributeLink_class_0 = SWIGV8_CreateClassTemplate("_xmlSchemaAttributeLink");
_exports__xmlSchemaAttributeLink_class_0->SetCallHandler(_wrap_new__xmlSchemaAttributeLink);
_exports__xmlSchemaAttributeLink_class_0->Inherit(_exports__xmlSchemaAttributeLink_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlSchemaAttributeLink_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlSchemaAttributeLink_obj = _exports__xmlSchemaAttributeLink_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlSchemaAttributeLink_obj = _exports__xmlSchemaAttributeLink_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlSchemaWildcardNs (_exports__xmlSchemaWildcardNs) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaWildcardNs_class_0 = SWIGV8_CreateClassTemplate("_xmlSchemaWildcardNs");
_exports__xmlSchemaWildcardNs_class_0->SetCallHandler(_wrap_new__xmlSchemaWildcardNs);
_exports__xmlSchemaWildcardNs_class_0->Inherit(_exports__xmlSchemaWildcardNs_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlSchemaWildcardNs_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlSchemaWildcardNs_obj = _exports__xmlSchemaWildcardNs_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlSchemaWildcardNs_obj = _exports__xmlSchemaWildcardNs_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlSchemaWildcard (_exports__xmlSchemaWildcard) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaWildcard_class_0 = SWIGV8_CreateClassTemplate("_xmlSchemaWildcard");
_exports__xmlSchemaWildcard_class_0->SetCallHandler(_wrap_new__xmlSchemaWildcard);
_exports__xmlSchemaWildcard_class_0->Inherit(_exports__xmlSchemaWildcard_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlSchemaWildcard_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlSchemaWildcard_obj = _exports__xmlSchemaWildcard_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlSchemaWildcard_obj = _exports__xmlSchemaWildcard_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlSchemaAttributeGroup (_exports__xmlSchemaAttributeGroup) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaAttributeGroup_class_0 = SWIGV8_CreateClassTemplate("_xmlSchemaAttributeGroup");
_exports__xmlSchemaAttributeGroup_class_0->SetCallHandler(_wrap_new__xmlSchemaAttributeGroup);
_exports__xmlSchemaAttributeGroup_class_0->Inherit(_exports__xmlSchemaAttributeGroup_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlSchemaAttributeGroup_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlSchemaAttributeGroup_obj = _exports__xmlSchemaAttributeGroup_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlSchemaAttributeGroup_obj = _exports__xmlSchemaAttributeGroup_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlSchemaTypeLink (_exports__xmlSchemaTypeLink) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaTypeLink_class_0 = SWIGV8_CreateClassTemplate("_xmlSchemaTypeLink");
_exports__xmlSchemaTypeLink_class_0->SetCallHandler(_wrap_new__xmlSchemaTypeLink);
_exports__xmlSchemaTypeLink_class_0->Inherit(_exports__xmlSchemaTypeLink_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlSchemaTypeLink_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlSchemaTypeLink_obj = _exports__xmlSchemaTypeLink_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlSchemaTypeLink_obj = _exports__xmlSchemaTypeLink_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlSchemaFacetLink (_exports__xmlSchemaFacetLink) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaFacetLink_class_0 = SWIGV8_CreateClassTemplate("_xmlSchemaFacetLink");
_exports__xmlSchemaFacetLink_class_0->SetCallHandler(_wrap_new__xmlSchemaFacetLink);
_exports__xmlSchemaFacetLink_class_0->Inherit(_exports__xmlSchemaFacetLink_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlSchemaFacetLink_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlSchemaFacetLink_obj = _exports__xmlSchemaFacetLink_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlSchemaFacetLink_obj = _exports__xmlSchemaFacetLink_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlSchemaType (_exports__xmlSchemaType) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaType_class_0 = SWIGV8_CreateClassTemplate("_xmlSchemaType");
_exports__xmlSchemaType_class_0->SetCallHandler(_wrap_new__xmlSchemaType);
_exports__xmlSchemaType_class_0->Inherit(_exports__xmlSchemaType_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlSchemaType_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlSchemaType_obj = _exports__xmlSchemaType_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlSchemaType_obj = _exports__xmlSchemaType_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlSchemaElement (_exports__xmlSchemaElement) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaElement_class_0 = SWIGV8_CreateClassTemplate("_xmlSchemaElement");
_exports__xmlSchemaElement_class_0->SetCallHandler(_wrap_new__xmlSchemaElement);
_exports__xmlSchemaElement_class_0->Inherit(_exports__xmlSchemaElement_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlSchemaElement_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlSchemaElement_obj = _exports__xmlSchemaElement_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlSchemaElement_obj = _exports__xmlSchemaElement_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlSchemaFacet (_exports__xmlSchemaFacet) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaFacet_class_0 = SWIGV8_CreateClassTemplate("_xmlSchemaFacet");
_exports__xmlSchemaFacet_class_0->SetCallHandler(_wrap_new__xmlSchemaFacet);
_exports__xmlSchemaFacet_class_0->Inherit(_exports__xmlSchemaFacet_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlSchemaFacet_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlSchemaFacet_obj = _exports__xmlSchemaFacet_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlSchemaFacet_obj = _exports__xmlSchemaFacet_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlSchemaNotation (_exports__xmlSchemaNotation) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchemaNotation_class_0 = SWIGV8_CreateClassTemplate("_xmlSchemaNotation");
_exports__xmlSchemaNotation_class_0->SetCallHandler(_wrap_new__xmlSchemaNotation);
_exports__xmlSchemaNotation_class_0->Inherit(_exports__xmlSchemaNotation_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlSchemaNotation_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlSchemaNotation_obj = _exports__xmlSchemaNotation_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlSchemaNotation_obj = _exports__xmlSchemaNotation_class_0->GetFunction(context).ToLocalChecked();
#endif
/* Class: _xmlSchema (_exports__xmlSchema) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlSchema_class_0 = SWIGV8_CreateClassTemplate("_xmlSchema");
_exports__xmlSchema_class_0->SetCallHandler(_wrap_new__xmlSchema);
_exports__xmlSchema_class_0->Inherit(_exports__xmlSchema_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlSchema_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlSchema_obj = _exports__xmlSchema_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlSchema_obj = _exports__xmlSchema_class_0->GetFunction(context).ToLocalChecked();
#endif


  /* add static class functions and variables */
  SWIGV8_AddStaticFunction(exports_obj, "setDebugEnable", _wrap_setDebugEnable, context);
SWIGV8_AddStaticFunction(exports_obj, "setDebugDisable", _wrap_setDebugDisable, context);
SWIGV8_AddStaticFunction(exports_obj, "getMemUsed", _wrap_getMemUsed, context);
SWIGV8_AddStaticFunction(exports_obj, "getNodeCount", _wrap_getNodeCount, context);
SWIGV8_AddStaticFunction(exports_obj, "getWrapCount", _wrap_getWrapCount, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDocHasRootElement", _wrap_xmlDocHasRootElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUnlinkNode", _wrap_xmlUnlinkNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCheckVersion", _wrap_xmlCheckVersion, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStrdup", _wrap_xmlStrdup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStrndup", _wrap_xmlStrndup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCharStrndup", _wrap_xmlCharStrndup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCharStrdup", _wrap_xmlCharStrdup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStrsub", _wrap_xmlStrsub, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStrchr", _wrap_xmlStrchr, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStrstr", _wrap_xmlStrstr, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStrcasestr", _wrap_xmlStrcasestr, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStrcmp", _wrap_xmlStrcmp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStrncmp", _wrap_xmlStrncmp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStrcasecmp", _wrap_xmlStrcasecmp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStrncasecmp", _wrap_xmlStrncasecmp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStrEqual", _wrap_xmlStrEqual, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStrQEqual", _wrap_xmlStrQEqual, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStrlen", _wrap_xmlStrlen, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStrcat", _wrap_xmlStrcat, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStrncat", _wrap_xmlStrncat, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStrncatNew", _wrap_xmlStrncatNew, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStrPrintf", _wrap_xmlStrPrintf, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetUTF8Char", _wrap_xmlGetUTF8Char, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCheckUTF8", _wrap_xmlCheckUTF8, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUTF8Strsize", _wrap_xmlUTF8Strsize, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUTF8Strndup", _wrap_xmlUTF8Strndup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUTF8Strpos", _wrap_xmlUTF8Strpos, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUTF8Strloc", _wrap_xmlUTF8Strloc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUTF8Strsub", _wrap_xmlUTF8Strsub, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUTF8Strlen", _wrap_xmlUTF8Strlen, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUTF8Size", _wrap_xmlUTF8Size, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUTF8Charcmp", _wrap_xmlUTF8Charcmp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMemSetup", _wrap_xmlMemSetup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMemGet", _wrap_xmlMemGet, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGcMemSetup", _wrap_xmlGcMemSetup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGcMemGet", _wrap_xmlGcMemGet, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlInitMemory", _wrap_xmlInitMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCleanupMemory", _wrap_xmlCleanupMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMemSize", _wrap_xmlMemSize, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMemUsed", _wrap_xmlMemUsed, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMemBlocks", _wrap_xmlMemBlocks, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMemDisplay", _wrap_xmlMemDisplay, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMemDisplayLast", _wrap_xmlMemDisplayLast, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMemShow", _wrap_xmlMemShow, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMemoryDump", _wrap_xmlMemoryDump, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMemMalloc", _wrap_xmlMemMalloc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMemRealloc", _wrap_xmlMemRealloc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMemFree", _wrap_xmlMemFree, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMemoryStrdup", _wrap_xmlMemoryStrdup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMallocLoc", _wrap_xmlMallocLoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReallocLoc", _wrap_xmlReallocLoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMallocAtomicLoc", _wrap_xmlMallocAtomicLoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMemStrdupLoc", _wrap_xmlMemStrdupLoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegexpCompile", _wrap_xmlRegexpCompile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegFreeRegexp", _wrap_xmlRegFreeRegexp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegexpExec", _wrap_xmlRegexpExec, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegexpPrint", _wrap_xmlRegexpPrint, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegexpIsDeterminist", _wrap_xmlRegexpIsDeterminist, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegNewExecCtxt", _wrap_xmlRegNewExecCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegFreeExecCtxt", _wrap_xmlRegFreeExecCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegExecPushString", _wrap_xmlRegExecPushString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegExecPushString2", _wrap_xmlRegExecPushString2, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegExecNextValues", _wrap_xmlRegExecNextValues, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegExecErrInfo", _wrap_xmlRegExecErrInfo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufContent", _wrap_xmlBufContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufEnd", _wrap_xmlBufEnd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufUse", _wrap_xmlBufUse, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufShrink", _wrap_xmlBufShrink, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlBufferAllocScheme", _wrap___xmlBufferAllocScheme, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlDefaultBufferSize", _wrap___xmlDefaultBufferSize, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlRegisterNodeDefaultValue", _wrap___xmlRegisterNodeDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlDeregisterNodeDefaultValue", _wrap___xmlDeregisterNodeDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateNCName", _wrap_xmlValidateNCName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateQName", _wrap_xmlValidateQName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateName", _wrap_xmlValidateName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateNMToken", _wrap_xmlValidateNMToken, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBuildQName", _wrap_xmlBuildQName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSplitQName2", _wrap_xmlSplitQName2, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSplitQName3", _wrap_xmlSplitQName3, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSetBufferAllocationScheme", _wrap_xmlSetBufferAllocationScheme, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetBufferAllocationScheme", _wrap_xmlGetBufferAllocationScheme, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferCreate", _wrap_xmlBufferCreate, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferCreateSize", _wrap_xmlBufferCreateSize, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferCreateStatic", _wrap_xmlBufferCreateStatic, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferResize", _wrap_xmlBufferResize, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferFree", _wrap_xmlBufferFree, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferDump", _wrap_xmlBufferDump, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferAdd", _wrap_xmlBufferAdd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferAddHead", _wrap_xmlBufferAddHead, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferCat", _wrap_xmlBufferCat, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferCCat", _wrap_xmlBufferCCat, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferShrink", _wrap_xmlBufferShrink, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferGrow", _wrap_xmlBufferGrow, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferEmpty", _wrap_xmlBufferEmpty, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferContent", _wrap_xmlBufferContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferDetach", _wrap_xmlBufferDetach, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferSetAllocationScheme", _wrap_xmlBufferSetAllocationScheme, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferLength", _wrap_xmlBufferLength, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCreateIntSubset", _wrap_xmlCreateIntSubset, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewDtd", _wrap_xmlNewDtd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetIntSubset", _wrap_xmlGetIntSubset, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeDtd", _wrap_xmlFreeDtd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewNs", _wrap_xmlNewNs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeNs", _wrap_xmlFreeNs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeNsList", _wrap_xmlFreeNsList, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewDoc", _wrap_xmlNewDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeDoc", _wrap_xmlFreeDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewDocProp", _wrap_xmlNewDocProp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewProp", _wrap_xmlNewProp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewNsProp", _wrap_xmlNewNsProp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewNsPropEatName", _wrap_xmlNewNsPropEatName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreePropList", _wrap_xmlFreePropList, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeProp", _wrap_xmlFreeProp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyProp", _wrap_xmlCopyProp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyPropList", _wrap_xmlCopyPropList, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyDtd", _wrap_xmlCopyDtd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyDoc", _wrap_xmlCopyDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewDocNode", _wrap_xmlNewDocNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewDocNodeEatName", _wrap_xmlNewDocNodeEatName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewNode", _wrap_xmlNewNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewNodeEatName", _wrap_xmlNewNodeEatName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewChild", _wrap_xmlNewChild, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewDocText", _wrap_xmlNewDocText, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewText", _wrap_xmlNewText, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewDocPI", _wrap_xmlNewDocPI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewPI", _wrap_xmlNewPI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewDocTextLen", _wrap_xmlNewDocTextLen, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewTextLen", _wrap_xmlNewTextLen, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewDocComment", _wrap_xmlNewDocComment, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewComment", _wrap_xmlNewComment, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewCDataBlock", _wrap_xmlNewCDataBlock, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewCharRef", _wrap_xmlNewCharRef, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewReference", _wrap_xmlNewReference, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyNode", _wrap_xmlCopyNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDocCopyNode", _wrap_xmlDocCopyNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDocCopyNodeList", _wrap_xmlDocCopyNodeList, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyNodeList", _wrap_xmlCopyNodeList, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewTextChild", _wrap_xmlNewTextChild, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewDocRawNode", _wrap_xmlNewDocRawNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewDocFragment", _wrap_xmlNewDocFragment, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetLineNo", _wrap_xmlGetLineNo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetNodePath", _wrap_xmlGetNodePath, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDocGetRootElement", _wrap_xmlDocGetRootElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetLastChild", _wrap_xmlGetLastChild, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeIsText", _wrap_xmlNodeIsText, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlIsBlankNode", _wrap_xmlIsBlankNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDocSetRootElement", _wrap_xmlDocSetRootElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeSetName", _wrap_xmlNodeSetName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAddChild", _wrap_xmlAddChild, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAddChildList", _wrap_xmlAddChildList, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReplaceNode", _wrap_xmlReplaceNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAddPrevSibling", _wrap_xmlAddPrevSibling, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAddSibling", _wrap_xmlAddSibling, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAddNextSibling", _wrap_xmlAddNextSibling, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextMerge", _wrap_xmlTextMerge, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextConcat", _wrap_xmlTextConcat, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeNodeList", _wrap_xmlFreeNodeList, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeNode", _wrap_xmlFreeNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSetTreeDoc", _wrap_xmlSetTreeDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSetListDoc", _wrap_xmlSetListDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSearchNs", _wrap_xmlSearchNs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSearchNsByHref", _wrap_xmlSearchNsByHref, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetNsListSafe", _wrap_xmlGetNsListSafe, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetNsList", _wrap_xmlGetNsList, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSetNs", _wrap_xmlSetNs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyNamespace", _wrap_xmlCopyNamespace, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyNamespaceList", _wrap_xmlCopyNamespaceList, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSetProp", _wrap_xmlSetProp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSetNsProp", _wrap_xmlSetNsProp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeGetAttrValue", _wrap_xmlNodeGetAttrValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetNoNsProp", _wrap_xmlGetNoNsProp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetProp", _wrap_xmlGetProp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHasProp", _wrap_xmlHasProp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHasNsProp", _wrap_xmlHasNsProp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetNsProp", _wrap_xmlGetNsProp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStringGetNodeList", _wrap_xmlStringGetNodeList, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStringLenGetNodeList", _wrap_xmlStringLenGetNodeList, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeListGetString", _wrap_xmlNodeListGetString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeListGetRawString", _wrap_xmlNodeListGetRawString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeSetContent", _wrap_xmlNodeSetContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeSetContentLen", _wrap_xmlNodeSetContentLen, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeAddContent", _wrap_xmlNodeAddContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeAddContentLen", _wrap_xmlNodeAddContentLen, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeGetContent", _wrap_xmlNodeGetContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeBufGetContent", _wrap_xmlNodeBufGetContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufGetNodeContent", _wrap_xmlBufGetNodeContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeGetLang", _wrap_xmlNodeGetLang, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeGetSpacePreserve", _wrap_xmlNodeGetSpacePreserve, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeSetLang", _wrap_xmlNodeSetLang, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeSetSpacePreserve", _wrap_xmlNodeSetSpacePreserve, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeGetBaseSafe", _wrap_xmlNodeGetBaseSafe, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeGetBase", _wrap_xmlNodeGetBase, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeSetBase", _wrap_xmlNodeSetBase, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRemoveProp", _wrap_xmlRemoveProp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUnsetNsProp", _wrap_xmlUnsetNsProp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUnsetProp", _wrap_xmlUnsetProp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferWriteCHAR", _wrap_xmlBufferWriteCHAR, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferWriteChar", _wrap_xmlBufferWriteChar, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufferWriteQuotedString", _wrap_xmlBufferWriteQuotedString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAttrSerializeTxtContent", _wrap_xmlAttrSerializeTxtContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReconciliateNs", _wrap_xmlReconciliateNs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDocDumpFormatMemory", _wrap_xmlDocDumpFormatMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDocDumpMemory", _wrap_xmlDocDumpMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDocDumpMemoryEnc", _wrap_xmlDocDumpMemoryEnc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDocDumpFormatMemoryEnc", _wrap_xmlDocDumpFormatMemoryEnc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDocFormatDump", _wrap_xmlDocFormatDump, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDocDump", _wrap_xmlDocDump, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlElemDump", _wrap_xmlElemDump, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveFile", _wrap_xmlSaveFile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveFormatFile", _wrap_xmlSaveFormatFile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBufNodeDump", _wrap_xmlBufNodeDump, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeDump", _wrap_xmlNodeDump, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveFileTo", _wrap_xmlSaveFileTo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveFormatFileTo", _wrap_xmlSaveFormatFileTo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNodeDumpOutput", _wrap_xmlNodeDumpOutput, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveFormatFileEnc", _wrap_xmlSaveFormatFileEnc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveFileEnc", _wrap_xmlSaveFileEnc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlIsXHTML", _wrap_xmlIsXHTML, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetDocCompressMode", _wrap_xmlGetDocCompressMode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSetDocCompressMode", _wrap_xmlSetDocCompressMode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetCompressMode", _wrap_xmlGetCompressMode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSetCompressMode", _wrap_xmlSetCompressMode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDOMWrapNewCtxt", _wrap_xmlDOMWrapNewCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDOMWrapFreeCtxt", _wrap_xmlDOMWrapFreeCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDOMWrapReconcileNamespaces", _wrap_xmlDOMWrapReconcileNamespaces, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDOMWrapAdoptNode", _wrap_xmlDOMWrapAdoptNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDOMWrapRemoveNode", _wrap_xmlDOMWrapRemoveNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDOMWrapCloneNode", _wrap_xmlDOMWrapCloneNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlChildElementCount", _wrap_xmlChildElementCount, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNextElementSibling", _wrap_xmlNextElementSibling, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFirstElementChild", _wrap_xmlFirstElementChild, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlLastElementChild", _wrap_xmlLastElementChild, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlPreviousElementSibling", _wrap_xmlPreviousElementSibling, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegisterNodeDefault", _wrap_xmlRegisterNodeDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDeregisterNodeDefault", _wrap_xmlDeregisterNodeDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefRegisterNodeDefault", _wrap_xmlThrDefRegisterNodeDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefDeregisterNodeDefault", _wrap_xmlThrDefDeregisterNodeDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefBufferAllocScheme", _wrap_xmlThrDefBufferAllocScheme, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefDefaultBufferSize", _wrap_xmlThrDefDefaultBufferSize, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlInitializeDict", _wrap_xmlInitializeDict, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDictCreate", _wrap_xmlDictCreate, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDictSetLimit", _wrap_xmlDictSetLimit, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDictGetUsage", _wrap_xmlDictGetUsage, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDictCreateSub", _wrap_xmlDictCreateSub, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDictReference", _wrap_xmlDictReference, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDictFree", _wrap_xmlDictFree, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDictLookup", _wrap_xmlDictLookup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDictExists", _wrap_xmlDictExists, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDictQLookup", _wrap_xmlDictQLookup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDictOwns", _wrap_xmlDictOwns, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDictSize", _wrap_xmlDictSize, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDictCleanup", _wrap_xmlDictCleanup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashCreate", _wrap_xmlHashCreate, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashCreateDict", _wrap_xmlHashCreateDict, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashFree", _wrap_xmlHashFree, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashDefaultDeallocator", _wrap_xmlHashDefaultDeallocator, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashAdd", _wrap_xmlHashAdd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashAddEntry", _wrap_xmlHashAddEntry, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashUpdateEntry", _wrap_xmlHashUpdateEntry, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashAdd2", _wrap_xmlHashAdd2, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashAddEntry2", _wrap_xmlHashAddEntry2, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashUpdateEntry2", _wrap_xmlHashUpdateEntry2, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashAdd3", _wrap_xmlHashAdd3, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashAddEntry3", _wrap_xmlHashAddEntry3, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashUpdateEntry3", _wrap_xmlHashUpdateEntry3, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashRemoveEntry", _wrap_xmlHashRemoveEntry, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashRemoveEntry2", _wrap_xmlHashRemoveEntry2, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashRemoveEntry3", _wrap_xmlHashRemoveEntry3, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashLookup", _wrap_xmlHashLookup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashLookup2", _wrap_xmlHashLookup2, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashLookup3", _wrap_xmlHashLookup3, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashQLookup", _wrap_xmlHashQLookup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashQLookup2", _wrap_xmlHashQLookup2, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashQLookup3", _wrap_xmlHashQLookup3, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashCopySafe", _wrap_xmlHashCopySafe, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashCopy", _wrap_xmlHashCopy, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashSize", _wrap_xmlHashSize, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashScan", _wrap_xmlHashScan, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashScan3", _wrap_xmlHashScan3, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashScanFull", _wrap_xmlHashScanFull, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashScanFull3", _wrap_xmlHashScanFull3, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlLastError", _wrap___xmlLastError, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlGenericError", _wrap___xmlGenericError, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlGenericErrorContext", _wrap___xmlGenericErrorContext, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlStructuredError", _wrap___xmlStructuredError, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlStructuredErrorContext", _wrap___xmlStructuredErrorContext, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSetGenericErrorFunc", _wrap_xmlSetGenericErrorFunc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefSetGenericErrorFunc", _wrap_xmlThrDefSetGenericErrorFunc, context);
SWIGV8_AddStaticFunction(exports_obj, "initGenericErrorDefaultFunc", _wrap_initGenericErrorDefaultFunc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSetStructuredErrorFunc", _wrap_xmlSetStructuredErrorFunc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefSetStructuredErrorFunc", _wrap_xmlThrDefSetStructuredErrorFunc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserError", _wrap_xmlParserError, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserWarning", _wrap_xmlParserWarning, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserValidityError", _wrap_xmlParserValidityError, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserValidityWarning", _wrap_xmlParserValidityWarning, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserPrintFileInfo", _wrap_xmlParserPrintFileInfo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserPrintFileContext", _wrap_xmlParserPrintFileContext, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFormatError", _wrap_xmlFormatError, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetLastError", _wrap_xmlGetLastError, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlResetLastError", _wrap_xmlResetLastError, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCtxtGetLastError", _wrap_xmlCtxtGetLastError, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCtxtResetLastError", _wrap_xmlCtxtResetLastError, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlResetError", _wrap_xmlResetError, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyError", _wrap_xmlCopyError, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListCreate", _wrap_xmlListCreate, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListDelete", _wrap_xmlListDelete, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListSearch", _wrap_xmlListSearch, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListReverseSearch", _wrap_xmlListReverseSearch, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListInsert", _wrap_xmlListInsert, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListAppend", _wrap_xmlListAppend, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListRemoveFirst", _wrap_xmlListRemoveFirst, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListRemoveLast", _wrap_xmlListRemoveLast, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListRemoveAll", _wrap_xmlListRemoveAll, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListClear", _wrap_xmlListClear, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListEmpty", _wrap_xmlListEmpty, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListFront", _wrap_xmlListFront, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListEnd", _wrap_xmlListEnd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListSize", _wrap_xmlListSize, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListPopFront", _wrap_xmlListPopFront, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListPopBack", _wrap_xmlListPopBack, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListPushFront", _wrap_xmlListPushFront, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListPushBack", _wrap_xmlListPushBack, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListReverse", _wrap_xmlListReverse, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListSort", _wrap_xmlListSort, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListWalk", _wrap_xmlListWalk, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListReverseWalk", _wrap_xmlListReverseWalk, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListMerge", _wrap_xmlListMerge, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListDup", _wrap_xmlListDup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlListCopy", _wrap_xmlListCopy, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlLinkGetData", _wrap_xmlLinkGetData, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewAutomata", _wrap_xmlNewAutomata, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeAutomata", _wrap_xmlFreeAutomata, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAutomataGetInitState", _wrap_xmlAutomataGetInitState, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAutomataSetFinalState", _wrap_xmlAutomataSetFinalState, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAutomataNewState", _wrap_xmlAutomataNewState, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAutomataNewTransition", _wrap_xmlAutomataNewTransition, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAutomataNewTransition2", _wrap_xmlAutomataNewTransition2, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAutomataNewNegTrans", _wrap_xmlAutomataNewNegTrans, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAutomataNewCountTrans", _wrap_xmlAutomataNewCountTrans, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAutomataNewCountTrans2", _wrap_xmlAutomataNewCountTrans2, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAutomataNewOnceTrans", _wrap_xmlAutomataNewOnceTrans, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAutomataNewOnceTrans2", _wrap_xmlAutomataNewOnceTrans2, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAutomataNewAllTrans", _wrap_xmlAutomataNewAllTrans, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAutomataNewEpsilon", _wrap_xmlAutomataNewEpsilon, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAutomataNewCountedTrans", _wrap_xmlAutomataNewCountedTrans, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAutomataNewCounterTrans", _wrap_xmlAutomataNewCounterTrans, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAutomataNewCounter", _wrap_xmlAutomataNewCounter, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAutomataCompile", _wrap_xmlAutomataCompile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAutomataIsDeterminist", _wrap_xmlAutomataIsDeterminist, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAddNotationDecl", _wrap_xmlAddNotationDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyNotationTable", _wrap_xmlCopyNotationTable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeNotationTable", _wrap_xmlFreeNotationTable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDumpNotationDecl", _wrap_xmlDumpNotationDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDumpNotationTable", _wrap_xmlDumpNotationTable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewElementContent", _wrap_xmlNewElementContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyElementContent", _wrap_xmlCopyElementContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeElementContent", _wrap_xmlFreeElementContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewDocElementContent", _wrap_xmlNewDocElementContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyDocElementContent", _wrap_xmlCopyDocElementContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeDocElementContent", _wrap_xmlFreeDocElementContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSnprintfElementContent", _wrap_xmlSnprintfElementContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSprintfElementContent", _wrap_xmlSprintfElementContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAddElementDecl", _wrap_xmlAddElementDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyElementTable", _wrap_xmlCopyElementTable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeElementTable", _wrap_xmlFreeElementTable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDumpElementTable", _wrap_xmlDumpElementTable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDumpElementDecl", _wrap_xmlDumpElementDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCreateEnumeration", _wrap_xmlCreateEnumeration, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeEnumeration", _wrap_xmlFreeEnumeration, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyEnumeration", _wrap_xmlCopyEnumeration, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAddAttributeDecl", _wrap_xmlAddAttributeDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyAttributeTable", _wrap_xmlCopyAttributeTable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeAttributeTable", _wrap_xmlFreeAttributeTable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDumpAttributeTable", _wrap_xmlDumpAttributeTable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDumpAttributeDecl", _wrap_xmlDumpAttributeDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAddIDSafe", _wrap_xmlAddIDSafe, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAddID", _wrap_xmlAddID, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeIDTable", _wrap_xmlFreeIDTable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetID", _wrap_xmlGetID, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlIsID", _wrap_xmlIsID, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRemoveID", _wrap_xmlRemoveID, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAddRef", _wrap_xmlAddRef, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeRefTable", _wrap_xmlFreeRefTable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlIsRef", _wrap_xmlIsRef, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRemoveRef", _wrap_xmlRemoveRef, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetRefs", _wrap_xmlGetRefs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewValidCtxt", _wrap_xmlNewValidCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeValidCtxt", _wrap_xmlFreeValidCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateRoot", _wrap_xmlValidateRoot, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateElementDecl", _wrap_xmlValidateElementDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidNormalizeAttributeValue", _wrap_xmlValidNormalizeAttributeValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidCtxtNormalizeAttributeValue", _wrap_xmlValidCtxtNormalizeAttributeValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateAttributeDecl", _wrap_xmlValidateAttributeDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateAttributeValue", _wrap_xmlValidateAttributeValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateNotationDecl", _wrap_xmlValidateNotationDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateDtd", _wrap_xmlValidateDtd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateDtdFinal", _wrap_xmlValidateDtdFinal, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateDocument", _wrap_xmlValidateDocument, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateElement", _wrap_xmlValidateElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateOneElement", _wrap_xmlValidateOneElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateOneAttribute", _wrap_xmlValidateOneAttribute, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateOneNamespace", _wrap_xmlValidateOneNamespace, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateDocumentFinal", _wrap_xmlValidateDocumentFinal, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateNotationUse", _wrap_xmlValidateNotationUse, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlIsMixedElement", _wrap_xmlIsMixedElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetDtdAttrDesc", _wrap_xmlGetDtdAttrDesc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetDtdQAttrDesc", _wrap_xmlGetDtdQAttrDesc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetDtdNotationDesc", _wrap_xmlGetDtdNotationDesc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetDtdQElementDesc", _wrap_xmlGetDtdQElementDesc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetDtdElementDesc", _wrap_xmlGetDtdElementDesc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidGetPotentialChildren", _wrap_xmlValidGetPotentialChildren, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidGetValidElements", _wrap_xmlValidGetValidElements, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateNameValue", _wrap_xmlValidateNameValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateNamesValue", _wrap_xmlValidateNamesValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateNmtokenValue", _wrap_xmlValidateNmtokenValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidateNmtokensValue", _wrap_xmlValidateNmtokensValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidBuildContentModel", _wrap_xmlValidBuildContentModel, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidatePushElement", _wrap_xmlValidatePushElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidatePushCData", _wrap_xmlValidatePushCData, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlValidatePopElement", _wrap_xmlValidatePopElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewEntity", _wrap_xmlNewEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeEntity", _wrap_xmlFreeEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAddEntity", _wrap_xmlAddEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAddDocEntity", _wrap_xmlAddDocEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAddDtdEntity", _wrap_xmlAddDtdEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetPredefinedEntity", _wrap_xmlGetPredefinedEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetDocEntity", _wrap_xmlGetDocEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetDtdEntity", _wrap_xmlGetDtdEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetParameterEntity", _wrap_xmlGetParameterEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlEncodeEntitiesReentrant", _wrap_xmlEncodeEntitiesReentrant, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlEncodeSpecialChars", _wrap_xmlEncodeSpecialChars, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCreateEntitiesTable", _wrap_xmlCreateEntitiesTable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyEntitiesTable", _wrap_xmlCopyEntitiesTable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeEntitiesTable", _wrap_xmlFreeEntitiesTable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDumpEntitiesTable", _wrap_xmlDumpEntitiesTable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDumpEntityDecl", _wrap_xmlDumpEntityDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlInitCharEncodingHandlers", _wrap_xmlInitCharEncodingHandlers, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCleanupCharEncodingHandlers", _wrap_xmlCleanupCharEncodingHandlers, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegisterCharEncodingHandler", _wrap_xmlRegisterCharEncodingHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlLookupCharEncodingHandler", _wrap_xmlLookupCharEncodingHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlOpenCharEncodingHandler", _wrap_xmlOpenCharEncodingHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetCharEncodingHandler", _wrap_xmlGetCharEncodingHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFindCharEncodingHandler", _wrap_xmlFindCharEncodingHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewCharEncodingHandler", _wrap_xmlNewCharEncodingHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAddEncodingAlias", _wrap_xmlAddEncodingAlias, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDelEncodingAlias", _wrap_xmlDelEncodingAlias, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetEncodingAlias", _wrap_xmlGetEncodingAlias, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCleanupEncodingAliases", _wrap_xmlCleanupEncodingAliases, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseCharEncoding", _wrap_xmlParseCharEncoding, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetCharEncodingName", _wrap_xmlGetCharEncodingName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDetectCharEncoding", _wrap_xmlDetectCharEncoding, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCharEncOutFunc", _wrap_xmlCharEncOutFunc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCharEncInFunc", _wrap_xmlCharEncInFunc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCharEncFirstLine", _wrap_xmlCharEncFirstLine, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCharEncCloseFunc", _wrap_xmlCharEncCloseFunc, context);
SWIGV8_AddStaticFunction(exports_obj, "UTF8Toisolat1", _wrap_UTF8Toisolat1, context);
SWIGV8_AddStaticFunction(exports_obj, "isolat1ToUTF8", _wrap_isolat1ToUTF8, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlParserInputBufferCreateFilenameValue", _wrap___xmlParserInputBufferCreateFilenameValue, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlOutputBufferCreateFilenameValue", _wrap___xmlOutputBufferCreateFilenameValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCleanupInputCallbacks", _wrap_xmlCleanupInputCallbacks, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlPopInputCallbacks", _wrap_xmlPopInputCallbacks, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegisterDefaultInputCallbacks", _wrap_xmlRegisterDefaultInputCallbacks, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAllocParserInputBuffer", _wrap_xmlAllocParserInputBuffer, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserInputBufferCreateFilename", _wrap_xmlParserInputBufferCreateFilename, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserInputBufferCreateFile", _wrap_xmlParserInputBufferCreateFile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserInputBufferCreateFd", _wrap_xmlParserInputBufferCreateFd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserInputBufferCreateMem", _wrap_xmlParserInputBufferCreateMem, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserInputBufferCreateStatic", _wrap_xmlParserInputBufferCreateStatic, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserInputBufferCreateIO", _wrap_xmlParserInputBufferCreateIO, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserInputBufferRead", _wrap_xmlParserInputBufferRead, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserInputBufferGrow", _wrap_xmlParserInputBufferGrow, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserInputBufferPush", _wrap_xmlParserInputBufferPush, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeParserInputBuffer", _wrap_xmlFreeParserInputBuffer, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserGetDirectory", _wrap_xmlParserGetDirectory, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegisterInputCallbacks", _wrap_xmlRegisterInputCallbacks, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlParserInputBufferCreateFilename", _wrap___xmlParserInputBufferCreateFilename, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCleanupOutputCallbacks", _wrap_xmlCleanupOutputCallbacks, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlPopOutputCallbacks", _wrap_xmlPopOutputCallbacks, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegisterDefaultOutputCallbacks", _wrap_xmlRegisterDefaultOutputCallbacks, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlAllocOutputBuffer", _wrap_xmlAllocOutputBuffer, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlOutputBufferCreateFilename", _wrap_xmlOutputBufferCreateFilename, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlOutputBufferCreateFile", _wrap_xmlOutputBufferCreateFile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlOutputBufferCreateBuffer", _wrap_xmlOutputBufferCreateBuffer, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlOutputBufferCreateFd", _wrap_xmlOutputBufferCreateFd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlOutputBufferCreateIO", _wrap_xmlOutputBufferCreateIO, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlOutputBufferGetContent", _wrap_xmlOutputBufferGetContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlOutputBufferGetSize", _wrap_xmlOutputBufferGetSize, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlOutputBufferWrite", _wrap_xmlOutputBufferWrite, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlOutputBufferWriteString", _wrap_xmlOutputBufferWriteString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlOutputBufferWriteEscape", _wrap_xmlOutputBufferWriteEscape, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlOutputBufferFlush", _wrap_xmlOutputBufferFlush, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlOutputBufferClose", _wrap_xmlOutputBufferClose, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegisterOutputCallbacks", _wrap_xmlRegisterOutputCallbacks, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlOutputBufferCreateFilename", _wrap___xmlOutputBufferCreateFilename, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCheckHTTPInput", _wrap_xmlCheckHTTPInput, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNoNetExternalEntityLoader", _wrap_xmlNoNetExternalEntityLoader, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNormalizeWindowsPath", _wrap_xmlNormalizeWindowsPath, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCheckFilename", _wrap_xmlCheckFilename, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFileMatch", _wrap_xmlFileMatch, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFileOpen", _wrap_xmlFileOpen, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFileRead", _wrap_xmlFileRead, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFileClose", _wrap_xmlFileClose, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserInputBufferCreateFilenameDefault", _wrap_xmlParserInputBufferCreateFilenameDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlOutputBufferCreateFilenameDefault", _wrap_xmlOutputBufferCreateFilenameDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefOutputBufferCreateFilenameDefault", _wrap_xmlThrDefOutputBufferCreateFilenameDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefParserInputBufferCreateFilenameDefault", _wrap_xmlThrDefParserInputBufferCreateFilenameDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2GetPublicId", _wrap_xmlSAX2GetPublicId, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2GetSystemId", _wrap_xmlSAX2GetSystemId, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2SetDocumentLocator", _wrap_xmlSAX2SetDocumentLocator, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2GetLineNumber", _wrap_xmlSAX2GetLineNumber, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2GetColumnNumber", _wrap_xmlSAX2GetColumnNumber, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2IsStandalone", _wrap_xmlSAX2IsStandalone, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2HasInternalSubset", _wrap_xmlSAX2HasInternalSubset, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2HasExternalSubset", _wrap_xmlSAX2HasExternalSubset, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2InternalSubset", _wrap_xmlSAX2InternalSubset, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2ExternalSubset", _wrap_xmlSAX2ExternalSubset, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2GetEntity", _wrap_xmlSAX2GetEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2GetParameterEntity", _wrap_xmlSAX2GetParameterEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2ResolveEntity", _wrap_xmlSAX2ResolveEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2EntityDecl", _wrap_xmlSAX2EntityDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2AttributeDecl", _wrap_xmlSAX2AttributeDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2ElementDecl", _wrap_xmlSAX2ElementDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2NotationDecl", _wrap_xmlSAX2NotationDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2UnparsedEntityDecl", _wrap_xmlSAX2UnparsedEntityDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2StartDocument", _wrap_xmlSAX2StartDocument, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2EndDocument", _wrap_xmlSAX2EndDocument, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2StartElement", _wrap_xmlSAX2StartElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2EndElement", _wrap_xmlSAX2EndElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2StartElementNs", _wrap_xmlSAX2StartElementNs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2EndElementNs", _wrap_xmlSAX2EndElementNs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2Reference", _wrap_xmlSAX2Reference, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2Characters", _wrap_xmlSAX2Characters, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2IgnorableWhitespace", _wrap_xmlSAX2IgnorableWhitespace, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2ProcessingInstruction", _wrap_xmlSAX2ProcessingInstruction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2Comment", _wrap_xmlSAX2Comment, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2CDataBlock", _wrap_xmlSAX2CDataBlock, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAXDefaultVersion", _wrap_xmlSAXDefaultVersion, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAXVersion", _wrap_xmlSAXVersion, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2InitDefaultSAXHandler", _wrap_xmlSAX2InitDefaultSAXHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAX2InitHtmlDefaultSAXHandler", _wrap_xmlSAX2InitHtmlDefaultSAXHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlDefaultSAXHandlerInit", _wrap_htmlDefaultSAXHandlerInit, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDefaultSAXHandlerInit", _wrap_xmlDefaultSAXHandlerInit, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCheckThreadLocalStorage", _wrap_xmlCheckThreadLocalStorage, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewMutex", _wrap_xmlNewMutex, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMutexLock", _wrap_xmlMutexLock, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlMutexUnlock", _wrap_xmlMutexUnlock, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeMutex", _wrap_xmlFreeMutex, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewRMutex", _wrap_xmlNewRMutex, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRMutexLock", _wrap_xmlRMutexLock, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRMutexUnlock", _wrap_xmlRMutexUnlock, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeRMutex", _wrap_xmlFreeRMutex, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlInitThreads", _wrap_xmlInitThreads, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlLockLibrary", _wrap_xmlLockLibrary, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUnlockLibrary", _wrap_xmlUnlockLibrary, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetThreadId", _wrap_xmlGetThreadId, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlIsMainThread", _wrap_xmlIsMainThread, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCleanupThreads", _wrap_xmlCleanupThreads, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlParserVersion", _wrap___xmlParserVersion, context);
SWIGV8_AddStaticFunction(exports_obj, "__oldXMLWDcompatibility", _wrap___oldXMLWDcompatibility, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlParserDebugEntities", _wrap___xmlParserDebugEntities, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlDefaultSAXLocator", _wrap___xmlDefaultSAXLocator, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlDefaultSAXHandler", _wrap___xmlDefaultSAXHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlDoValidityCheckingDefaultValue", _wrap___xmlDoValidityCheckingDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlGetWarningsDefaultValue", _wrap___xmlGetWarningsDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlKeepBlanksDefaultValue", _wrap___xmlKeepBlanksDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlLineNumbersDefaultValue", _wrap___xmlLineNumbersDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlLoadExtDtdDefaultValue", _wrap___xmlLoadExtDtdDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlPedanticParserDefaultValue", _wrap___xmlPedanticParserDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlSubstituteEntitiesDefaultValue", _wrap___xmlSubstituteEntitiesDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlIndentTreeOutput", _wrap___xmlIndentTreeOutput, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlTreeIndentString", _wrap___xmlTreeIndentString, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlSaveNoEmptyTags", _wrap___xmlSaveNoEmptyTags, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlInitParser", _wrap_xmlInitParser, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCleanupParser", _wrap_xmlCleanupParser, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlInitGlobals", _wrap_xmlInitGlobals, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCleanupGlobals", _wrap_xmlCleanupGlobals, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserInputRead", _wrap_xmlParserInputRead, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserInputGrow", _wrap_xmlParserInputGrow, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseDoc", _wrap_xmlParseDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseFile", _wrap_xmlParseFile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseMemory", _wrap_xmlParseMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSubstituteEntitiesDefault", _wrap_xmlSubstituteEntitiesDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefSubstituteEntitiesDefaultValue", _wrap_xmlThrDefSubstituteEntitiesDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlKeepBlanksDefault", _wrap_xmlKeepBlanksDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefKeepBlanksDefaultValue", _wrap_xmlThrDefKeepBlanksDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStopParser", _wrap_xmlStopParser, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlPedanticParserDefault", _wrap_xmlPedanticParserDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefPedanticParserDefaultValue", _wrap_xmlThrDefPedanticParserDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlLineNumbersDefault", _wrap_xmlLineNumbersDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefLineNumbersDefaultValue", _wrap_xmlThrDefLineNumbersDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefDoValidityCheckingDefaultValue", _wrap_xmlThrDefDoValidityCheckingDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefGetWarningsDefaultValue", _wrap_xmlThrDefGetWarningsDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefLoadExtDtdDefaultValue", _wrap_xmlThrDefLoadExtDtdDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefParserDebugEntities", _wrap_xmlThrDefParserDebugEntities, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRecoverDoc", _wrap_xmlRecoverDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRecoverMemory", _wrap_xmlRecoverMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRecoverFile", _wrap_xmlRecoverFile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseDocument", _wrap_xmlParseDocument, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseExtParsedEnt", _wrap_xmlParseExtParsedEnt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAXUserParseFile", _wrap_xmlSAXUserParseFile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAXUserParseMemory", _wrap_xmlSAXUserParseMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAXParseDoc", _wrap_xmlSAXParseDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAXParseMemory", _wrap_xmlSAXParseMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAXParseMemoryWithData", _wrap_xmlSAXParseMemoryWithData, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAXParseFile", _wrap_xmlSAXParseFile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAXParseFileWithData", _wrap_xmlSAXParseFileWithData, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAXParseEntity", _wrap_xmlSAXParseEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseEntity", _wrap_xmlParseEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSAXParseDTD", _wrap_xmlSAXParseDTD, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseDTD", _wrap_xmlParseDTD, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlIOParseDTD", _wrap_xmlIOParseDTD, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseBalancedChunkMemory", _wrap_xmlParseBalancedChunkMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseInNodeContext", _wrap_xmlParseInNodeContext, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseBalancedChunkMemoryRecover", _wrap_xmlParseBalancedChunkMemoryRecover, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseExternalEntity", _wrap_xmlParseExternalEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseCtxtExternalEntity", _wrap_xmlParseCtxtExternalEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewParserCtxt", _wrap_xmlNewParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewSAXParserCtxt", _wrap_xmlNewSAXParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlInitParserCtxt", _wrap_xmlInitParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlClearParserCtxt", _wrap_xmlClearParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeParserCtxt", _wrap_xmlFreeParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSetupParserForBuffer", _wrap_xmlSetupParserForBuffer, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCreateDocParserCtxt", _wrap_xmlCreateDocParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCreatePushParserCtxt", _wrap_xmlCreatePushParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseChunk", _wrap_xmlParseChunk, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCreateIOParserCtxt", _wrap_xmlCreateIOParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewIOInputStream", _wrap_xmlNewIOInputStream, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserFindNodeInfo", _wrap_xmlParserFindNodeInfo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlInitNodeInfoSeq", _wrap_xmlInitNodeInfoSeq, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlClearNodeInfoSeq", _wrap_xmlClearNodeInfoSeq, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserFindNodeInfoIndex", _wrap_xmlParserFindNodeInfoIndex, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserAddNodeInfo", _wrap_xmlParserAddNodeInfo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSetExternalEntityLoader", _wrap_xmlSetExternalEntityLoader, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetExternalEntityLoader", _wrap_xmlGetExternalEntityLoader, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlLoadExternalEntity", _wrap_xmlLoadExternalEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlByteConsumed", _wrap_xmlByteConsumed, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCtxtReset", _wrap_xmlCtxtReset, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCtxtResetPush", _wrap_xmlCtxtResetPush, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCtxtSetOptions", _wrap_xmlCtxtSetOptions, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCtxtUseOptions", _wrap_xmlCtxtUseOptions, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCtxtSetErrorHandler", _wrap_xmlCtxtSetErrorHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCtxtSetMaxAmplification", _wrap_xmlCtxtSetMaxAmplification, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReadDoc", _wrap_xmlReadDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReadFile", _wrap_xmlReadFile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReadMemory", _wrap_xmlReadMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReadFd", _wrap_xmlReadFd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReadIO", _wrap_xmlReadIO, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCtxtParseDocument", _wrap_xmlCtxtParseDocument, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCtxtReadDoc", _wrap_xmlCtxtReadDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCtxtReadFile", _wrap_xmlCtxtReadFile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCtxtReadMemory", _wrap_xmlCtxtReadMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCtxtReadFd", _wrap_xmlCtxtReadFd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCtxtReadIO", _wrap_xmlCtxtReadIO, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHasFeature", _wrap_xmlHasFeature, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathFreeObject", _wrap_xmlXPathFreeObject, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNodeSetCreate", _wrap_xmlXPathNodeSetCreate, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathFreeNodeSetList", _wrap_xmlXPathFreeNodeSetList, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathFreeNodeSet", _wrap_xmlXPathFreeNodeSet, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathObjectCopy", _wrap_xmlXPathObjectCopy, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCmpNodes", _wrap_xmlXPathCmpNodes, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCastNumberToBoolean", _wrap_xmlXPathCastNumberToBoolean, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCastStringToBoolean", _wrap_xmlXPathCastStringToBoolean, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCastNodeSetToBoolean", _wrap_xmlXPathCastNodeSetToBoolean, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCastToBoolean", _wrap_xmlXPathCastToBoolean, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCastBooleanToNumber", _wrap_xmlXPathCastBooleanToNumber, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCastStringToNumber", _wrap_xmlXPathCastStringToNumber, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCastNodeToNumber", _wrap_xmlXPathCastNodeToNumber, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCastNodeSetToNumber", _wrap_xmlXPathCastNodeSetToNumber, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCastToNumber", _wrap_xmlXPathCastToNumber, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCastBooleanToString", _wrap_xmlXPathCastBooleanToString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCastNumberToString", _wrap_xmlXPathCastNumberToString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCastNodeToString", _wrap_xmlXPathCastNodeToString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCastNodeSetToString", _wrap_xmlXPathCastNodeSetToString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCastToString", _wrap_xmlXPathCastToString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathConvertBoolean", _wrap_xmlXPathConvertBoolean, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathConvertNumber", _wrap_xmlXPathConvertNumber, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathConvertString", _wrap_xmlXPathConvertString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNewContext", _wrap_xmlXPathNewContext, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathFreeContext", _wrap_xmlXPathFreeContext, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathSetErrorHandler", _wrap_xmlXPathSetErrorHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathContextSetCache", _wrap_xmlXPathContextSetCache, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathOrderDocElems", _wrap_xmlXPathOrderDocElems, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathSetContextNode", _wrap_xmlXPathSetContextNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNodeEval", _wrap_xmlXPathNodeEval, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathEval", _wrap_xmlXPathEval, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathEvalExpression", _wrap_xmlXPathEvalExpression, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathEvalPredicate", _wrap_xmlXPathEvalPredicate, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCompile", _wrap_xmlXPathCompile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCtxtCompile", _wrap_xmlXPathCtxtCompile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCompiledEval", _wrap_xmlXPathCompiledEval, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCompiledEvalToBoolean", _wrap_xmlXPathCompiledEvalToBoolean, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathFreeCompExpr", _wrap_xmlXPathFreeCompExpr, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathInit", _wrap_xmlXPathInit, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathIsNaN", _wrap_xmlXPathIsNaN, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathIsInf", _wrap_xmlXPathIsInf, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathPopBoolean", _wrap_xmlXPathPopBoolean, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathPopNumber", _wrap_xmlXPathPopNumber, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathPopString", _wrap_xmlXPathPopString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathPopNodeSet", _wrap_xmlXPathPopNodeSet, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathPopExternal", _wrap_xmlXPathPopExternal, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathRegisterVariableLookup", _wrap_xmlXPathRegisterVariableLookup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathRegisterFuncLookup", _wrap_xmlXPathRegisterFuncLookup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPatherror", _wrap_xmlXPatherror, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathErr", _wrap_xmlXPathErr, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathDebugDumpObject", _wrap_xmlXPathDebugDumpObject, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathDebugDumpCompExpr", _wrap_xmlXPathDebugDumpCompExpr, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNodeSetContains", _wrap_xmlXPathNodeSetContains, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathDifference", _wrap_xmlXPathDifference, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathIntersection", _wrap_xmlXPathIntersection, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathDistinctSorted", _wrap_xmlXPathDistinctSorted, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathDistinct", _wrap_xmlXPathDistinct, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathHasSameNodes", _wrap_xmlXPathHasSameNodes, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNodeLeadingSorted", _wrap_xmlXPathNodeLeadingSorted, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathLeadingSorted", _wrap_xmlXPathLeadingSorted, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNodeLeading", _wrap_xmlXPathNodeLeading, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathLeading", _wrap_xmlXPathLeading, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNodeTrailingSorted", _wrap_xmlXPathNodeTrailingSorted, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathTrailingSorted", _wrap_xmlXPathTrailingSorted, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNodeTrailing", _wrap_xmlXPathNodeTrailing, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathTrailing", _wrap_xmlXPathTrailing, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathRegisterNs", _wrap_xmlXPathRegisterNs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNsLookup", _wrap_xmlXPathNsLookup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathRegisteredNsCleanup", _wrap_xmlXPathRegisteredNsCleanup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathRegisterFunc", _wrap_xmlXPathRegisterFunc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathRegisterFuncNS", _wrap_xmlXPathRegisterFuncNS, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathRegisterVariable", _wrap_xmlXPathRegisterVariable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathRegisterVariableNS", _wrap_xmlXPathRegisterVariableNS, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathFunctionLookup", _wrap_xmlXPathFunctionLookup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathFunctionLookupNS", _wrap_xmlXPathFunctionLookupNS, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathRegisteredFuncsCleanup", _wrap_xmlXPathRegisteredFuncsCleanup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathVariableLookup", _wrap_xmlXPathVariableLookup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathVariableLookupNS", _wrap_xmlXPathVariableLookupNS, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathRegisteredVariablesCleanup", _wrap_xmlXPathRegisteredVariablesCleanup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNewParserContext", _wrap_xmlXPathNewParserContext, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathFreeParserContext", _wrap_xmlXPathFreeParserContext, context);
SWIGV8_AddStaticFunction(exports_obj, "valuePop", _wrap_valuePop, context);
SWIGV8_AddStaticFunction(exports_obj, "valuePush", _wrap_valuePush, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNewString", _wrap_xmlXPathNewString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNewCString", _wrap_xmlXPathNewCString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathWrapString", _wrap_xmlXPathWrapString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathWrapCString", _wrap_xmlXPathWrapCString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNewFloat", _wrap_xmlXPathNewFloat, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNewBoolean", _wrap_xmlXPathNewBoolean, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNewNodeSet", _wrap_xmlXPathNewNodeSet, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNewValueTree", _wrap_xmlXPathNewValueTree, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNodeSetAdd", _wrap_xmlXPathNodeSetAdd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNodeSetAddUnique", _wrap_xmlXPathNodeSetAddUnique, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNodeSetAddNs", _wrap_xmlXPathNodeSetAddNs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNodeSetSort", _wrap_xmlXPathNodeSetSort, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathRoot", _wrap_xmlXPathRoot, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathEvalExpr", _wrap_xmlXPathEvalExpr, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathParseName", _wrap_xmlXPathParseName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathParseNCName", _wrap_xmlXPathParseNCName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathStringEvalNumber", _wrap_xmlXPathStringEvalNumber, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathEvaluatePredicateResult", _wrap_xmlXPathEvaluatePredicateResult, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathRegisterAllFunctions", _wrap_xmlXPathRegisterAllFunctions, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNodeSetMerge", _wrap_xmlXPathNodeSetMerge, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNodeSetDel", _wrap_xmlXPathNodeSetDel, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNodeSetRemove", _wrap_xmlXPathNodeSetRemove, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNewNodeSetList", _wrap_xmlXPathNewNodeSetList, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathWrapNodeSet", _wrap_xmlXPathWrapNodeSet, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathWrapExternal", _wrap_xmlXPathWrapExternal, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathEqualValues", _wrap_xmlXPathEqualValues, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNotEqualValues", _wrap_xmlXPathNotEqualValues, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCompareValues", _wrap_xmlXPathCompareValues, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathValueFlipSign", _wrap_xmlXPathValueFlipSign, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathAddValues", _wrap_xmlXPathAddValues, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathSubValues", _wrap_xmlXPathSubValues, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathMultValues", _wrap_xmlXPathMultValues, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathDivValues", _wrap_xmlXPathDivValues, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathModValues", _wrap_xmlXPathModValues, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathIsNodeType", _wrap_xmlXPathIsNodeType, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNextSelf", _wrap_xmlXPathNextSelf, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNextChild", _wrap_xmlXPathNextChild, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNextDescendant", _wrap_xmlXPathNextDescendant, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNextDescendantOrSelf", _wrap_xmlXPathNextDescendantOrSelf, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNextParent", _wrap_xmlXPathNextParent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNextAncestorOrSelf", _wrap_xmlXPathNextAncestorOrSelf, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNextFollowingSibling", _wrap_xmlXPathNextFollowingSibling, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNextFollowing", _wrap_xmlXPathNextFollowing, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNextNamespace", _wrap_xmlXPathNextNamespace, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNextAttribute", _wrap_xmlXPathNextAttribute, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNextPreceding", _wrap_xmlXPathNextPreceding, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNextAncestor", _wrap_xmlXPathNextAncestor, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNextPrecedingSibling", _wrap_xmlXPathNextPrecedingSibling, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathLastFunction", _wrap_xmlXPathLastFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathPositionFunction", _wrap_xmlXPathPositionFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCountFunction", _wrap_xmlXPathCountFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathIdFunction", _wrap_xmlXPathIdFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathLocalNameFunction", _wrap_xmlXPathLocalNameFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNamespaceURIFunction", _wrap_xmlXPathNamespaceURIFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathStringFunction", _wrap_xmlXPathStringFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathStringLengthFunction", _wrap_xmlXPathStringLengthFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathConcatFunction", _wrap_xmlXPathConcatFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathContainsFunction", _wrap_xmlXPathContainsFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathStartsWithFunction", _wrap_xmlXPathStartsWithFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathSubstringFunction", _wrap_xmlXPathSubstringFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathSubstringBeforeFunction", _wrap_xmlXPathSubstringBeforeFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathSubstringAfterFunction", _wrap_xmlXPathSubstringAfterFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNormalizeFunction", _wrap_xmlXPathNormalizeFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathTranslateFunction", _wrap_xmlXPathTranslateFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNotFunction", _wrap_xmlXPathNotFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathTrueFunction", _wrap_xmlXPathTrueFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathFalseFunction", _wrap_xmlXPathFalseFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathLangFunction", _wrap_xmlXPathLangFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNumberFunction", _wrap_xmlXPathNumberFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathSumFunction", _wrap_xmlXPathSumFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathFloorFunction", _wrap_xmlXPathFloorFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathCeilingFunction", _wrap_xmlXPathCeilingFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathRoundFunction", _wrap_xmlXPathRoundFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathBooleanFunction", _wrap_xmlXPathBooleanFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPathNodeSetFreeNs", _wrap_xmlXPathNodeSetFreeNs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewCatalog", _wrap_xmlNewCatalog, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlLoadACatalog", _wrap_xmlLoadACatalog, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlLoadSGMLSuperCatalog", _wrap_xmlLoadSGMLSuperCatalog, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlConvertSGMLCatalog", _wrap_xmlConvertSGMLCatalog, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlACatalogAdd", _wrap_xmlACatalogAdd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlACatalogRemove", _wrap_xmlACatalogRemove, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlACatalogResolve", _wrap_xmlACatalogResolve, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlACatalogResolveSystem", _wrap_xmlACatalogResolveSystem, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlACatalogResolvePublic", _wrap_xmlACatalogResolvePublic, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlACatalogResolveURI", _wrap_xmlACatalogResolveURI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlACatalogDump", _wrap_xmlACatalogDump, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeCatalog", _wrap_xmlFreeCatalog, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogIsEmpty", _wrap_xmlCatalogIsEmpty, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlInitializeCatalog", _wrap_xmlInitializeCatalog, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlLoadCatalog", _wrap_xmlLoadCatalog, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlLoadCatalogs", _wrap_xmlLoadCatalogs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogCleanup", _wrap_xmlCatalogCleanup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogDump", _wrap_xmlCatalogDump, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogResolve", _wrap_xmlCatalogResolve, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogResolveSystem", _wrap_xmlCatalogResolveSystem, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogResolvePublic", _wrap_xmlCatalogResolvePublic, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogResolveURI", _wrap_xmlCatalogResolveURI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogAdd", _wrap_xmlCatalogAdd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogRemove", _wrap_xmlCatalogRemove, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseCatalogFile", _wrap_xmlParseCatalogFile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogConvert", _wrap_xmlCatalogConvert, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogFreeLocal", _wrap_xmlCatalogFreeLocal, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogAddLocal", _wrap_xmlCatalogAddLocal, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogLocalResolve", _wrap_xmlCatalogLocalResolve, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogLocalResolveURI", _wrap_xmlCatalogLocalResolveURI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogSetDebug", _wrap_xmlCatalogSetDebug, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogSetDefaultPrefer", _wrap_xmlCatalogSetDefaultPrefer, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogSetDefaults", _wrap_xmlCatalogSetDefaults, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogGetDefaults", _wrap_xmlCatalogGetDefaults, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogGetSystem", _wrap_xmlCatalogGetSystem, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCatalogGetPublic", _wrap_xmlCatalogGetPublic, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCharInRange", _wrap_xmlCharInRange, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlIsBaseChar", _wrap_xmlIsBaseChar, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlIsBlank", _wrap_xmlIsBlank, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlIsChar", _wrap_xmlIsChar, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlIsCombining", _wrap_xmlIsCombining, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlIsDigit", _wrap_xmlIsDigit, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlIsExtender", _wrap_xmlIsExtender, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlIsIdeographic", _wrap_xmlIsIdeographic, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlIsPubidChar", _wrap_xmlIsPubidChar, context);
SWIGV8_AddStaticFunction(exports_obj, "__htmlDefaultSAXHandler", _wrap___htmlDefaultSAXHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlInitAutoClose", _wrap_htmlInitAutoClose, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlTagLookup", _wrap_htmlTagLookup, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlEntityLookup", _wrap_htmlEntityLookup, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlEntityValueLookup", _wrap_htmlEntityValueLookup, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlIsAutoClosed", _wrap_htmlIsAutoClosed, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlAutoCloseTag", _wrap_htmlAutoCloseTag, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlParseEntityRef", _wrap_htmlParseEntityRef, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlParseCharRef", _wrap_htmlParseCharRef, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlParseElement", _wrap_htmlParseElement, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlNewParserCtxt", _wrap_htmlNewParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlNewSAXParserCtxt", _wrap_htmlNewSAXParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlCreateMemoryParserCtxt", _wrap_htmlCreateMemoryParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlParseDocument", _wrap_htmlParseDocument, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlSAXParseDoc", _wrap_htmlSAXParseDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlParseDoc", _wrap_htmlParseDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlCreateFileParserCtxt", _wrap_htmlCreateFileParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlSAXParseFile", _wrap_htmlSAXParseFile, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlParseFile", _wrap_htmlParseFile, context);
SWIGV8_AddStaticFunction(exports_obj, "UTF8ToHtml", _wrap_UTF8ToHtml, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlEncodeEntities", _wrap_htmlEncodeEntities, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlIsScriptAttribute", _wrap_htmlIsScriptAttribute, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlHandleOmittedElem", _wrap_htmlHandleOmittedElem, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlCreatePushParserCtxt", _wrap_htmlCreatePushParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlParseChunk", _wrap_htmlParseChunk, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlFreeParserCtxt", _wrap_htmlFreeParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlCtxtReset", _wrap_htmlCtxtReset, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlCtxtUseOptions", _wrap_htmlCtxtUseOptions, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlReadDoc", _wrap_htmlReadDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlReadFile", _wrap_htmlReadFile, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlReadMemory", _wrap_htmlReadMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlReadFd", _wrap_htmlReadFd, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlReadIO", _wrap_htmlReadIO, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlCtxtParseDocument", _wrap_htmlCtxtParseDocument, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlCtxtReadDoc", _wrap_htmlCtxtReadDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlCtxtReadFile", _wrap_htmlCtxtReadFile, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlCtxtReadMemory", _wrap_htmlCtxtReadMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlCtxtReadFd", _wrap_htmlCtxtReadFd, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlCtxtReadIO", _wrap_htmlCtxtReadIO, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlAttrAllowed", _wrap_htmlAttrAllowed, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlElementAllowedHere", _wrap_htmlElementAllowedHere, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlElementStatusHere", _wrap_htmlElementStatusHere, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlNodeStatus", _wrap_htmlNodeStatus, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveToFd", _wrap_xmlSaveToFd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveToFilename", _wrap_xmlSaveToFilename, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveToBuffer", _wrap_xmlSaveToBuffer, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveToIO", _wrap_xmlSaveToIO, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveDoc", _wrap_xmlSaveDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveTree", _wrap_xmlSaveTree, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveFlush", _wrap_xmlSaveFlush, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveClose", _wrap_xmlSaveClose, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveFinish", _wrap_xmlSaveFinish, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveSetEscape", _wrap_xmlSaveSetEscape, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveSetAttrEscape", _wrap_xmlSaveSetAttrEscape, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefIndentTreeOutput", _wrap_xmlThrDefIndentTreeOutput, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefTreeIndentString", _wrap_xmlThrDefTreeIndentString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefSaveNoEmptyTags", _wrap_xmlThrDefSaveNoEmptyTags, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlInitializeGlobalState", _wrap_xmlInitializeGlobalState, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetGlobalState", _wrap_xmlGetGlobalState, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlNewDoc", _wrap_htmlNewDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlNewDocNoDtD", _wrap_htmlNewDocNoDtD, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlGetMetaEncoding", _wrap_htmlGetMetaEncoding, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlSetMetaEncoding", _wrap_htmlSetMetaEncoding, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlDocDumpMemory", _wrap_htmlDocDumpMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlDocDumpMemoryFormat", _wrap_htmlDocDumpMemoryFormat, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlDocDump", _wrap_htmlDocDump, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlSaveFile", _wrap_htmlSaveFile, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlNodeDump", _wrap_htmlNodeDump, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlNodeDumpFile", _wrap_htmlNodeDumpFile, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlNodeDumpFileFormat", _wrap_htmlNodeDumpFileFormat, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlSaveFileEnc", _wrap_htmlSaveFileEnc, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlSaveFileFormat", _wrap_htmlSaveFileFormat, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlNodeDumpFormatOutput", _wrap_htmlNodeDumpFormatOutput, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlDocContentDumpOutput", _wrap_htmlDocContentDumpOutput, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlDocContentDumpFormatOutput", _wrap_htmlDocContentDumpFormatOutput, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlNodeDumpOutput", _wrap_htmlNodeDumpOutput, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlIsBooleanAttr", _wrap_htmlIsBooleanAttr, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlIsLetter", _wrap_xmlIsLetter, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCreateFileParserCtxt", _wrap_xmlCreateFileParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCreateURLParserCtxt", _wrap_xmlCreateURLParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCreateMemoryParserCtxt", _wrap_xmlCreateMemoryParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCreateEntityParserCtxt", _wrap_xmlCreateEntityParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCtxtErrMemory", _wrap_xmlCtxtErrMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSwitchEncoding", _wrap_xmlSwitchEncoding, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSwitchEncodingName", _wrap_xmlSwitchEncodingName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSwitchToEncoding", _wrap_xmlSwitchToEncoding, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSwitchInputEncoding", _wrap_xmlSwitchInputEncoding, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewStringInputStream", _wrap_xmlNewStringInputStream, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewEntityInputStream", _wrap_xmlNewEntityInputStream, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlPushInput", _wrap_xmlPushInput, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlPopInput", _wrap_xmlPopInput, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeInputStream", _wrap_xmlFreeInputStream, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewInputFromFile", _wrap_xmlNewInputFromFile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewInputStream", _wrap_xmlNewInputStream, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSplitQName", _wrap_xmlSplitQName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseName", _wrap_xmlParseName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseNmtoken", _wrap_xmlParseNmtoken, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseEntityValue", _wrap_xmlParseEntityValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseAttValue", _wrap_xmlParseAttValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseSystemLiteral", _wrap_xmlParseSystemLiteral, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParsePubidLiteral", _wrap_xmlParsePubidLiteral, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseCharData", _wrap_xmlParseCharData, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseExternalID", _wrap_xmlParseExternalID, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseComment", _wrap_xmlParseComment, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParsePITarget", _wrap_xmlParsePITarget, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParsePI", _wrap_xmlParsePI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseNotationDecl", _wrap_xmlParseNotationDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseEntityDecl", _wrap_xmlParseEntityDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseDefaultDecl", _wrap_xmlParseDefaultDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseNotationType", _wrap_xmlParseNotationType, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseEnumerationType", _wrap_xmlParseEnumerationType, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseEnumeratedType", _wrap_xmlParseEnumeratedType, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseAttributeType", _wrap_xmlParseAttributeType, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseAttributeListDecl", _wrap_xmlParseAttributeListDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseElementMixedContentDecl", _wrap_xmlParseElementMixedContentDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseElementChildrenContentDecl", _wrap_xmlParseElementChildrenContentDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseElementContentDecl", _wrap_xmlParseElementContentDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseElementDecl", _wrap_xmlParseElementDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseMarkupDecl", _wrap_xmlParseMarkupDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseCharRef", _wrap_xmlParseCharRef, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseEntityRef", _wrap_xmlParseEntityRef, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseReference", _wrap_xmlParseReference, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParsePEReference", _wrap_xmlParsePEReference, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseDocTypeDecl", _wrap_xmlParseDocTypeDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseAttribute", _wrap_xmlParseAttribute, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseStartTag", _wrap_xmlParseStartTag, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseEndTag", _wrap_xmlParseEndTag, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseCDSect", _wrap_xmlParseCDSect, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseContent", _wrap_xmlParseContent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseElement", _wrap_xmlParseElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseVersionNum", _wrap_xmlParseVersionNum, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseVersionInfo", _wrap_xmlParseVersionInfo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseEncName", _wrap_xmlParseEncName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseEncodingDecl", _wrap_xmlParseEncodingDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseSDDecl", _wrap_xmlParseSDDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseXMLDecl", _wrap_xmlParseXMLDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseTextDecl", _wrap_xmlParseTextDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseMisc", _wrap_xmlParseMisc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseExternalSubset", _wrap_xmlParseExternalSubset, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStringDecodeEntities", _wrap_xmlStringDecodeEntities, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStringLenDecodeEntities", _wrap_xmlStringLenDecodeEntities, context);
SWIGV8_AddStaticFunction(exports_obj, "nodePush", _wrap_nodePush, context);
SWIGV8_AddStaticFunction(exports_obj, "nodePop", _wrap_nodePop, context);
SWIGV8_AddStaticFunction(exports_obj, "inputPush", _wrap_inputPush, context);
SWIGV8_AddStaticFunction(exports_obj, "inputPop", _wrap_inputPop, context);
SWIGV8_AddStaticFunction(exports_obj, "namePop", _wrap_namePop, context);
SWIGV8_AddStaticFunction(exports_obj, "namePush", _wrap_namePush, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSkipBlankChars", _wrap_xmlSkipBlankChars, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStringCurrentChar", _wrap_xmlStringCurrentChar, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserHandlePEReference", _wrap_xmlParserHandlePEReference, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCheckLanguageID", _wrap_xmlCheckLanguageID, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCurrentChar", _wrap_xmlCurrentChar, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyCharMultiByte", _wrap_xmlCopyCharMultiByte, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCopyChar", _wrap_xmlCopyChar, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNextChar", _wrap_xmlNextChar, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserInputShrink", _wrap_xmlParserInputShrink, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreePattern", _wrap_xmlFreePattern, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreePatternList", _wrap_xmlFreePatternList, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlPatterncompile", _wrap_xmlPatterncompile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlPatternCompileSafe", _wrap_xmlPatternCompileSafe, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlPatternMatch", _wrap_xmlPatternMatch, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlPatternStreamable", _wrap_xmlPatternStreamable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlPatternMaxDepth", _wrap_xmlPatternMaxDepth, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlPatternMinDepth", _wrap_xmlPatternMinDepth, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlPatternFromRoot", _wrap_xmlPatternFromRoot, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlPatternGetStreamCtxt", _wrap_xmlPatternGetStreamCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeStreamCtxt", _wrap_xmlFreeStreamCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStreamPushNode", _wrap_xmlStreamPushNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStreamPush", _wrap_xmlStreamPush, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStreamPushAttr", _wrap_xmlStreamPushAttr, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStreamPop", _wrap_xmlStreamPop, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStreamWantsAnyNode", _wrap_xmlStreamWantsAnyNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGInitTypes", _wrap_xmlRelaxNGInitTypes, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGCleanupTypes", _wrap_xmlRelaxNGCleanupTypes, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGNewParserCtxt", _wrap_xmlRelaxNGNewParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGNewMemParserCtxt", _wrap_xmlRelaxNGNewMemParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGNewDocParserCtxt", _wrap_xmlRelaxNGNewDocParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxParserSetFlag", _wrap_xmlRelaxParserSetFlag, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGFreeParserCtxt", _wrap_xmlRelaxNGFreeParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGSetParserErrors", _wrap_xmlRelaxNGSetParserErrors, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGGetParserErrors", _wrap_xmlRelaxNGGetParserErrors, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGSetParserStructuredErrors", _wrap_xmlRelaxNGSetParserStructuredErrors, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGParse", _wrap_xmlRelaxNGParse, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGFree", _wrap_xmlRelaxNGFree, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGDump", _wrap_xmlRelaxNGDump, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGDumpTree", _wrap_xmlRelaxNGDumpTree, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGSetValidErrors", _wrap_xmlRelaxNGSetValidErrors, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGGetValidErrors", _wrap_xmlRelaxNGGetValidErrors, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGSetValidStructuredErrors", _wrap_xmlRelaxNGSetValidStructuredErrors, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGNewValidCtxt", _wrap_xmlRelaxNGNewValidCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGFreeValidCtxt", _wrap_xmlRelaxNGFreeValidCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGValidateDoc", _wrap_xmlRelaxNGValidateDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGValidatePushElement", _wrap_xmlRelaxNGValidatePushElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGValidatePushCData", _wrap_xmlRelaxNGValidatePushCData, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGValidatePopElement", _wrap_xmlRelaxNGValidatePopElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRelaxNGValidateFullElement", _wrap_xmlRelaxNGValidateFullElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCreateURI", _wrap_xmlCreateURI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBuildURISafe", _wrap_xmlBuildURISafe, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBuildURI", _wrap_xmlBuildURI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBuildRelativeURISafe", _wrap_xmlBuildRelativeURISafe, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBuildRelativeURI", _wrap_xmlBuildRelativeURI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseURI", _wrap_xmlParseURI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseURISafe", _wrap_xmlParseURISafe, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseURIRaw", _wrap_xmlParseURIRaw, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseURIReference", _wrap_xmlParseURIReference, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveUri", _wrap_xmlSaveUri, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlPrintURI", _wrap_xmlPrintURI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlURIEscapeStr", _wrap_xmlURIEscapeStr, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlURIUnescapeString", _wrap_xmlURIUnescapeString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNormalizeURIPath", _wrap_xmlNormalizeURIPath, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlURIEscape", _wrap_xmlURIEscape, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeURI", _wrap_xmlFreeURI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCanonicPath", _wrap_xmlCanonicPath, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlPathToURI", _wrap_xmlPathToURI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXIncludeProcess", _wrap_xmlXIncludeProcess, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXIncludeProcessFlags", _wrap_xmlXIncludeProcessFlags, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXIncludeProcessFlagsData", _wrap_xmlXIncludeProcessFlagsData, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXIncludeProcessTreeFlagsData", _wrap_xmlXIncludeProcessTreeFlagsData, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXIncludeProcessTree", _wrap_xmlXIncludeProcessTree, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXIncludeProcessTreeFlags", _wrap_xmlXIncludeProcessTreeFlags, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXIncludeNewContext", _wrap_xmlXIncludeNewContext, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXIncludeSetFlags", _wrap_xmlXIncludeSetFlags, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXIncludeSetErrorHandler", _wrap_xmlXIncludeSetErrorHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXIncludeGetLastError", _wrap_xmlXIncludeGetLastError, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXIncludeFreeContext", _wrap_xmlXIncludeFreeContext, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXIncludeProcessNode", _wrap_xmlXIncludeProcessNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xlinkGetDefaultDetect", _wrap_xlinkGetDefaultDetect, context);
SWIGV8_AddStaticFunction(exports_obj, "xlinkSetDefaultDetect", _wrap_xlinkSetDefaultDetect, context);
SWIGV8_AddStaticFunction(exports_obj, "xlinkGetDefaultHandler", _wrap_xlinkGetDefaultHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "xlinkSetDefaultHandler", _wrap_xlinkSetDefaultHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "xlinkIsLink", _wrap_xlinkIsLink, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlModuleOpen", _wrap_xmlModuleOpen, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlModuleSymbol", _wrap_xmlModuleSymbol, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlModuleClose", _wrap_xmlModuleClose, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlModuleFree", _wrap_xmlModuleFree, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaNewParserCtxt", _wrap_xmlSchemaNewParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaNewMemParserCtxt", _wrap_xmlSchemaNewMemParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaNewDocParserCtxt", _wrap_xmlSchemaNewDocParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaFreeParserCtxt", _wrap_xmlSchemaFreeParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaSetParserErrors", _wrap_xmlSchemaSetParserErrors, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaSetParserStructuredErrors", _wrap_xmlSchemaSetParserStructuredErrors, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaGetParserErrors", _wrap_xmlSchemaGetParserErrors, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaIsValid", _wrap_xmlSchemaIsValid, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaParse", _wrap_xmlSchemaParse, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaFree", _wrap_xmlSchemaFree, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaDump", _wrap_xmlSchemaDump, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaSetValidErrors", _wrap_xmlSchemaSetValidErrors, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaSetValidStructuredErrors", _wrap_xmlSchemaSetValidStructuredErrors, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaGetValidErrors", _wrap_xmlSchemaGetValidErrors, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaSetValidOptions", _wrap_xmlSchemaSetValidOptions, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValidateSetFilename", _wrap_xmlSchemaValidateSetFilename, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValidCtxtGetOptions", _wrap_xmlSchemaValidCtxtGetOptions, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaNewValidCtxt", _wrap_xmlSchemaNewValidCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaFreeValidCtxt", _wrap_xmlSchemaFreeValidCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValidateDoc", _wrap_xmlSchemaValidateDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValidateOneElement", _wrap_xmlSchemaValidateOneElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValidateStream", _wrap_xmlSchemaValidateStream, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValidateFile", _wrap_xmlSchemaValidateFile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValidCtxtGetParserCtxt", _wrap_xmlSchemaValidCtxtGetParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaSAXPlug", _wrap_xmlSchemaSAXPlug, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaSAXUnplug", _wrap_xmlSchemaSAXUnplug, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValidateSetLocator", _wrap_xmlSchemaValidateSetLocator, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewTextReader", _wrap_xmlNewTextReader, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewTextReaderFilename", _wrap_xmlNewTextReaderFilename, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeTextReader", _wrap_xmlFreeTextReader, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderSetup", _wrap_xmlTextReaderSetup, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderSetMaxAmplification", _wrap_xmlTextReaderSetMaxAmplification, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderGetLastError", _wrap_xmlTextReaderGetLastError, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderRead", _wrap_xmlTextReaderRead, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderReadInnerXml", _wrap_xmlTextReaderReadInnerXml, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderReadOuterXml", _wrap_xmlTextReaderReadOuterXml, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderReadString", _wrap_xmlTextReaderReadString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderReadAttributeValue", _wrap_xmlTextReaderReadAttributeValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderAttributeCount", _wrap_xmlTextReaderAttributeCount, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderDepth", _wrap_xmlTextReaderDepth, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderHasAttributes", _wrap_xmlTextReaderHasAttributes, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderHasValue", _wrap_xmlTextReaderHasValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderIsDefault", _wrap_xmlTextReaderIsDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderIsEmptyElement", _wrap_xmlTextReaderIsEmptyElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderNodeType", _wrap_xmlTextReaderNodeType, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderQuoteChar", _wrap_xmlTextReaderQuoteChar, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderReadState", _wrap_xmlTextReaderReadState, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderIsNamespaceDecl", _wrap_xmlTextReaderIsNamespaceDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderConstBaseUri", _wrap_xmlTextReaderConstBaseUri, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderConstLocalName", _wrap_xmlTextReaderConstLocalName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderConstName", _wrap_xmlTextReaderConstName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderConstNamespaceUri", _wrap_xmlTextReaderConstNamespaceUri, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderConstPrefix", _wrap_xmlTextReaderConstPrefix, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderConstXmlLang", _wrap_xmlTextReaderConstXmlLang, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderConstString", _wrap_xmlTextReaderConstString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderConstValue", _wrap_xmlTextReaderConstValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderBaseUri", _wrap_xmlTextReaderBaseUri, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderLocalName", _wrap_xmlTextReaderLocalName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderName", _wrap_xmlTextReaderName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderNamespaceUri", _wrap_xmlTextReaderNamespaceUri, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderPrefix", _wrap_xmlTextReaderPrefix, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderXmlLang", _wrap_xmlTextReaderXmlLang, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderValue", _wrap_xmlTextReaderValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderClose", _wrap_xmlTextReaderClose, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderGetAttributeNo", _wrap_xmlTextReaderGetAttributeNo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderGetAttribute", _wrap_xmlTextReaderGetAttribute, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderGetAttributeNs", _wrap_xmlTextReaderGetAttributeNs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderGetRemainder", _wrap_xmlTextReaderGetRemainder, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderLookupNamespace", _wrap_xmlTextReaderLookupNamespace, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderMoveToAttributeNo", _wrap_xmlTextReaderMoveToAttributeNo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderMoveToAttribute", _wrap_xmlTextReaderMoveToAttribute, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderMoveToAttributeNs", _wrap_xmlTextReaderMoveToAttributeNs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderMoveToFirstAttribute", _wrap_xmlTextReaderMoveToFirstAttribute, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderMoveToNextAttribute", _wrap_xmlTextReaderMoveToNextAttribute, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderMoveToElement", _wrap_xmlTextReaderMoveToElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderNormalization", _wrap_xmlTextReaderNormalization, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderConstEncoding", _wrap_xmlTextReaderConstEncoding, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderSetParserProp", _wrap_xmlTextReaderSetParserProp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderGetParserProp", _wrap_xmlTextReaderGetParserProp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderCurrentNode", _wrap_xmlTextReaderCurrentNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderGetParserLineNumber", _wrap_xmlTextReaderGetParserLineNumber, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderGetParserColumnNumber", _wrap_xmlTextReaderGetParserColumnNumber, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderPreserve", _wrap_xmlTextReaderPreserve, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderPreservePattern", _wrap_xmlTextReaderPreservePattern, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderCurrentDoc", _wrap_xmlTextReaderCurrentDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderExpand", _wrap_xmlTextReaderExpand, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderNext", _wrap_xmlTextReaderNext, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderNextSibling", _wrap_xmlTextReaderNextSibling, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderIsValid", _wrap_xmlTextReaderIsValid, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderRelaxNGValidate", _wrap_xmlTextReaderRelaxNGValidate, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderRelaxNGValidateCtxt", _wrap_xmlTextReaderRelaxNGValidateCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderRelaxNGSetSchema", _wrap_xmlTextReaderRelaxNGSetSchema, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderSchemaValidate", _wrap_xmlTextReaderSchemaValidate, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderSchemaValidateCtxt", _wrap_xmlTextReaderSchemaValidateCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderSetSchema", _wrap_xmlTextReaderSetSchema, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderConstXmlVersion", _wrap_xmlTextReaderConstXmlVersion, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderStandalone", _wrap_xmlTextReaderStandalone, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderByteConsumed", _wrap_xmlTextReaderByteConsumed, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReaderWalker", _wrap_xmlReaderWalker, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReaderForDoc", _wrap_xmlReaderForDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReaderForFile", _wrap_xmlReaderForFile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReaderForMemory", _wrap_xmlReaderForMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReaderForFd", _wrap_xmlReaderForFd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReaderForIO", _wrap_xmlReaderForIO, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReaderNewWalker", _wrap_xmlReaderNewWalker, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReaderNewDoc", _wrap_xmlReaderNewDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReaderNewFile", _wrap_xmlReaderNewFile, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReaderNewMemory", _wrap_xmlReaderNewMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReaderNewFd", _wrap_xmlReaderNewFd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlReaderNewIO", _wrap_xmlReaderNewIO, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderLocatorLineNumber", _wrap_xmlTextReaderLocatorLineNumber, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderLocatorBaseURI", _wrap_xmlTextReaderLocatorBaseURI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderSetErrorHandler", _wrap_xmlTextReaderSetErrorHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderSetStructuredErrorHandler", _wrap_xmlTextReaderSetStructuredErrorHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextReaderGetErrorHandler", _wrap_xmlTextReaderGetErrorHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaFreeType", _wrap_xmlSchemaFreeType, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaFreeWildcard", _wrap_xmlSchemaFreeWildcard, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaInitTypes", _wrap_xmlSchemaInitTypes, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaCleanupTypes", _wrap_xmlSchemaCleanupTypes, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaGetPredefinedType", _wrap_xmlSchemaGetPredefinedType, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValidatePredefinedType", _wrap_xmlSchemaValidatePredefinedType, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValPredefTypeNode", _wrap_xmlSchemaValPredefTypeNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValidateFacet", _wrap_xmlSchemaValidateFacet, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValidateFacetWhtsp", _wrap_xmlSchemaValidateFacetWhtsp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaFreeValue", _wrap_xmlSchemaFreeValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaNewFacet", _wrap_xmlSchemaNewFacet, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaCheckFacet", _wrap_xmlSchemaCheckFacet, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaFreeFacet", _wrap_xmlSchemaFreeFacet, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaCompareValues", _wrap_xmlSchemaCompareValues, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaGetBuiltInListSimpleTypeItemType", _wrap_xmlSchemaGetBuiltInListSimpleTypeItemType, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValidateListSimpleTypeFacet", _wrap_xmlSchemaValidateListSimpleTypeFacet, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaGetBuiltInType", _wrap_xmlSchemaGetBuiltInType, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaIsBuiltInTypeFacet", _wrap_xmlSchemaIsBuiltInTypeFacet, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaCollapseString", _wrap_xmlSchemaCollapseString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaWhiteSpaceReplace", _wrap_xmlSchemaWhiteSpaceReplace, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaGetFacetValueAsULong", _wrap_xmlSchemaGetFacetValueAsULong, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValidateLengthFacet", _wrap_xmlSchemaValidateLengthFacet, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValidateLengthFacetWhtsp", _wrap_xmlSchemaValidateLengthFacetWhtsp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValPredefTypeNodeNoNorm", _wrap_xmlSchemaValPredefTypeNodeNoNorm, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaGetCanonValue", _wrap_xmlSchemaGetCanonValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaGetCanonValueWhtsp", _wrap_xmlSchemaGetCanonValueWhtsp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValueAppend", _wrap_xmlSchemaValueAppend, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValueGetNext", _wrap_xmlSchemaValueGetNext, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValueGetAsString", _wrap_xmlSchemaValueGetAsString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaValueGetAsBoolean", _wrap_xmlSchemaValueGetAsBoolean, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaNewStringValue", _wrap_xmlSchemaNewStringValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaNewNOTATIONValue", _wrap_xmlSchemaNewNOTATIONValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaNewQNameValue", _wrap_xmlSchemaNewQNameValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaCompareValuesWhtsp", _wrap_xmlSchemaCompareValuesWhtsp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaCopyValue", _wrap_xmlSchemaCopyValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSchemaGetValType", _wrap_xmlSchemaGetValType, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsAegeanNumbers", _wrap_xmlUCSIsAegeanNumbers, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsAlphabeticPresentationForms", _wrap_xmlUCSIsAlphabeticPresentationForms, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsArabic", _wrap_xmlUCSIsArabic, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsArabicPresentationFormsA", _wrap_xmlUCSIsArabicPresentationFormsA, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsArabicPresentationFormsB", _wrap_xmlUCSIsArabicPresentationFormsB, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsArmenian", _wrap_xmlUCSIsArmenian, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsArrows", _wrap_xmlUCSIsArrows, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsBasicLatin", _wrap_xmlUCSIsBasicLatin, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsBengali", _wrap_xmlUCSIsBengali, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsBlockElements", _wrap_xmlUCSIsBlockElements, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsBopomofo", _wrap_xmlUCSIsBopomofo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsBopomofoExtended", _wrap_xmlUCSIsBopomofoExtended, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsBoxDrawing", _wrap_xmlUCSIsBoxDrawing, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsBraillePatterns", _wrap_xmlUCSIsBraillePatterns, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsBuhid", _wrap_xmlUCSIsBuhid, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsByzantineMusicalSymbols", _wrap_xmlUCSIsByzantineMusicalSymbols, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCJKCompatibility", _wrap_xmlUCSIsCJKCompatibility, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCJKCompatibilityForms", _wrap_xmlUCSIsCJKCompatibilityForms, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCJKCompatibilityIdeographs", _wrap_xmlUCSIsCJKCompatibilityIdeographs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCJKCompatibilityIdeographsSupplement", _wrap_xmlUCSIsCJKCompatibilityIdeographsSupplement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCJKRadicalsSupplement", _wrap_xmlUCSIsCJKRadicalsSupplement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCJKSymbolsandPunctuation", _wrap_xmlUCSIsCJKSymbolsandPunctuation, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCJKUnifiedIdeographs", _wrap_xmlUCSIsCJKUnifiedIdeographs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCJKUnifiedIdeographsExtensionA", _wrap_xmlUCSIsCJKUnifiedIdeographsExtensionA, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCJKUnifiedIdeographsExtensionB", _wrap_xmlUCSIsCJKUnifiedIdeographsExtensionB, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCherokee", _wrap_xmlUCSIsCherokee, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCombiningDiacriticalMarks", _wrap_xmlUCSIsCombiningDiacriticalMarks, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCombiningDiacriticalMarksforSymbols", _wrap_xmlUCSIsCombiningDiacriticalMarksforSymbols, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCombiningHalfMarks", _wrap_xmlUCSIsCombiningHalfMarks, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCombiningMarksforSymbols", _wrap_xmlUCSIsCombiningMarksforSymbols, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsControlPictures", _wrap_xmlUCSIsControlPictures, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCurrencySymbols", _wrap_xmlUCSIsCurrencySymbols, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCypriotSyllabary", _wrap_xmlUCSIsCypriotSyllabary, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCyrillic", _wrap_xmlUCSIsCyrillic, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCyrillicSupplement", _wrap_xmlUCSIsCyrillicSupplement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsDeseret", _wrap_xmlUCSIsDeseret, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsDevanagari", _wrap_xmlUCSIsDevanagari, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsDingbats", _wrap_xmlUCSIsDingbats, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsEnclosedAlphanumerics", _wrap_xmlUCSIsEnclosedAlphanumerics, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsEnclosedCJKLettersandMonths", _wrap_xmlUCSIsEnclosedCJKLettersandMonths, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsEthiopic", _wrap_xmlUCSIsEthiopic, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsGeneralPunctuation", _wrap_xmlUCSIsGeneralPunctuation, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsGeometricShapes", _wrap_xmlUCSIsGeometricShapes, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsGeorgian", _wrap_xmlUCSIsGeorgian, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsGothic", _wrap_xmlUCSIsGothic, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsGreek", _wrap_xmlUCSIsGreek, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsGreekExtended", _wrap_xmlUCSIsGreekExtended, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsGreekandCoptic", _wrap_xmlUCSIsGreekandCoptic, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsGujarati", _wrap_xmlUCSIsGujarati, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsGurmukhi", _wrap_xmlUCSIsGurmukhi, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsHalfwidthandFullwidthForms", _wrap_xmlUCSIsHalfwidthandFullwidthForms, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsHangulCompatibilityJamo", _wrap_xmlUCSIsHangulCompatibilityJamo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsHangulJamo", _wrap_xmlUCSIsHangulJamo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsHangulSyllables", _wrap_xmlUCSIsHangulSyllables, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsHanunoo", _wrap_xmlUCSIsHanunoo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsHebrew", _wrap_xmlUCSIsHebrew, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsHighPrivateUseSurrogates", _wrap_xmlUCSIsHighPrivateUseSurrogates, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsHighSurrogates", _wrap_xmlUCSIsHighSurrogates, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsHiragana", _wrap_xmlUCSIsHiragana, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsIPAExtensions", _wrap_xmlUCSIsIPAExtensions, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsIdeographicDescriptionCharacters", _wrap_xmlUCSIsIdeographicDescriptionCharacters, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsKanbun", _wrap_xmlUCSIsKanbun, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsKangxiRadicals", _wrap_xmlUCSIsKangxiRadicals, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsKannada", _wrap_xmlUCSIsKannada, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsKatakana", _wrap_xmlUCSIsKatakana, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsKatakanaPhoneticExtensions", _wrap_xmlUCSIsKatakanaPhoneticExtensions, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsKhmer", _wrap_xmlUCSIsKhmer, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsKhmerSymbols", _wrap_xmlUCSIsKhmerSymbols, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsLao", _wrap_xmlUCSIsLao, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsLatin1Supplement", _wrap_xmlUCSIsLatin1Supplement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsLatinExtendedA", _wrap_xmlUCSIsLatinExtendedA, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsLatinExtendedB", _wrap_xmlUCSIsLatinExtendedB, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsLatinExtendedAdditional", _wrap_xmlUCSIsLatinExtendedAdditional, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsLetterlikeSymbols", _wrap_xmlUCSIsLetterlikeSymbols, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsLimbu", _wrap_xmlUCSIsLimbu, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsLinearBIdeograms", _wrap_xmlUCSIsLinearBIdeograms, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsLinearBSyllabary", _wrap_xmlUCSIsLinearBSyllabary, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsLowSurrogates", _wrap_xmlUCSIsLowSurrogates, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsMalayalam", _wrap_xmlUCSIsMalayalam, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsMathematicalAlphanumericSymbols", _wrap_xmlUCSIsMathematicalAlphanumericSymbols, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsMathematicalOperators", _wrap_xmlUCSIsMathematicalOperators, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsMiscellaneousMathematicalSymbolsA", _wrap_xmlUCSIsMiscellaneousMathematicalSymbolsA, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsMiscellaneousMathematicalSymbolsB", _wrap_xmlUCSIsMiscellaneousMathematicalSymbolsB, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsMiscellaneousSymbols", _wrap_xmlUCSIsMiscellaneousSymbols, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsMiscellaneousSymbolsandArrows", _wrap_xmlUCSIsMiscellaneousSymbolsandArrows, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsMiscellaneousTechnical", _wrap_xmlUCSIsMiscellaneousTechnical, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsMongolian", _wrap_xmlUCSIsMongolian, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsMusicalSymbols", _wrap_xmlUCSIsMusicalSymbols, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsMyanmar", _wrap_xmlUCSIsMyanmar, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsNumberForms", _wrap_xmlUCSIsNumberForms, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsOgham", _wrap_xmlUCSIsOgham, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsOldItalic", _wrap_xmlUCSIsOldItalic, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsOpticalCharacterRecognition", _wrap_xmlUCSIsOpticalCharacterRecognition, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsOriya", _wrap_xmlUCSIsOriya, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsOsmanya", _wrap_xmlUCSIsOsmanya, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsPhoneticExtensions", _wrap_xmlUCSIsPhoneticExtensions, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsPrivateUse", _wrap_xmlUCSIsPrivateUse, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsPrivateUseArea", _wrap_xmlUCSIsPrivateUseArea, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsRunic", _wrap_xmlUCSIsRunic, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsShavian", _wrap_xmlUCSIsShavian, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsSinhala", _wrap_xmlUCSIsSinhala, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsSmallFormVariants", _wrap_xmlUCSIsSmallFormVariants, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsSpacingModifierLetters", _wrap_xmlUCSIsSpacingModifierLetters, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsSpecials", _wrap_xmlUCSIsSpecials, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsSuperscriptsandSubscripts", _wrap_xmlUCSIsSuperscriptsandSubscripts, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsSupplementalArrowsA", _wrap_xmlUCSIsSupplementalArrowsA, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsSupplementalArrowsB", _wrap_xmlUCSIsSupplementalArrowsB, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsSupplementalMathematicalOperators", _wrap_xmlUCSIsSupplementalMathematicalOperators, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsSupplementaryPrivateUseAreaA", _wrap_xmlUCSIsSupplementaryPrivateUseAreaA, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsSupplementaryPrivateUseAreaB", _wrap_xmlUCSIsSupplementaryPrivateUseAreaB, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsSyriac", _wrap_xmlUCSIsSyriac, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsTagalog", _wrap_xmlUCSIsTagalog, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsTagbanwa", _wrap_xmlUCSIsTagbanwa, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsTags", _wrap_xmlUCSIsTags, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsTaiLe", _wrap_xmlUCSIsTaiLe, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsTaiXuanJingSymbols", _wrap_xmlUCSIsTaiXuanJingSymbols, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsTamil", _wrap_xmlUCSIsTamil, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsTelugu", _wrap_xmlUCSIsTelugu, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsThaana", _wrap_xmlUCSIsThaana, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsThai", _wrap_xmlUCSIsThai, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsTibetan", _wrap_xmlUCSIsTibetan, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsUgaritic", _wrap_xmlUCSIsUgaritic, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsUnifiedCanadianAboriginalSyllabics", _wrap_xmlUCSIsUnifiedCanadianAboriginalSyllabics, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsVariationSelectors", _wrap_xmlUCSIsVariationSelectors, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsVariationSelectorsSupplement", _wrap_xmlUCSIsVariationSelectorsSupplement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsYiRadicals", _wrap_xmlUCSIsYiRadicals, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsYiSyllables", _wrap_xmlUCSIsYiSyllables, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsYijingHexagramSymbols", _wrap_xmlUCSIsYijingHexagramSymbols, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsBlock", _wrap_xmlUCSIsBlock, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatC", _wrap_xmlUCSIsCatC, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatCc", _wrap_xmlUCSIsCatCc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatCf", _wrap_xmlUCSIsCatCf, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatCo", _wrap_xmlUCSIsCatCo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatCs", _wrap_xmlUCSIsCatCs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatL", _wrap_xmlUCSIsCatL, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatLl", _wrap_xmlUCSIsCatLl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatLm", _wrap_xmlUCSIsCatLm, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatLo", _wrap_xmlUCSIsCatLo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatLt", _wrap_xmlUCSIsCatLt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatLu", _wrap_xmlUCSIsCatLu, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatM", _wrap_xmlUCSIsCatM, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatMc", _wrap_xmlUCSIsCatMc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatMe", _wrap_xmlUCSIsCatMe, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatMn", _wrap_xmlUCSIsCatMn, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatN", _wrap_xmlUCSIsCatN, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatNd", _wrap_xmlUCSIsCatNd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatNl", _wrap_xmlUCSIsCatNl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatNo", _wrap_xmlUCSIsCatNo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatP", _wrap_xmlUCSIsCatP, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatPc", _wrap_xmlUCSIsCatPc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatPd", _wrap_xmlUCSIsCatPd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatPe", _wrap_xmlUCSIsCatPe, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatPf", _wrap_xmlUCSIsCatPf, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatPi", _wrap_xmlUCSIsCatPi, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatPo", _wrap_xmlUCSIsCatPo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatPs", _wrap_xmlUCSIsCatPs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatS", _wrap_xmlUCSIsCatS, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatSc", _wrap_xmlUCSIsCatSc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatSk", _wrap_xmlUCSIsCatSk, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatSm", _wrap_xmlUCSIsCatSm, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatSo", _wrap_xmlUCSIsCatSo, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatZ", _wrap_xmlUCSIsCatZ, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatZl", _wrap_xmlUCSIsCatZl, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatZp", _wrap_xmlUCSIsCatZp, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCatZs", _wrap_xmlUCSIsCatZs, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlUCSIsCat", _wrap_xmlUCSIsCat, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewTextWriter", _wrap_xmlNewTextWriter, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewTextWriterFilename", _wrap_xmlNewTextWriterFilename, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewTextWriterMemory", _wrap_xmlNewTextWriterMemory, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewTextWriterPushParser", _wrap_xmlNewTextWriterPushParser, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewTextWriterDoc", _wrap_xmlNewTextWriterDoc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewTextWriterTree", _wrap_xmlNewTextWriterTree, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlFreeTextWriter", _wrap_xmlFreeTextWriter, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterStartDocument", _wrap_xmlTextWriterStartDocument, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterEndDocument", _wrap_xmlTextWriterEndDocument, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterStartComment", _wrap_xmlTextWriterStartComment, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterEndComment", _wrap_xmlTextWriterEndComment, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteFormatComment", _wrap_xmlTextWriterWriteFormatComment, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteComment", _wrap_xmlTextWriterWriteComment, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterStartElement", _wrap_xmlTextWriterStartElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterStartElementNS", _wrap_xmlTextWriterStartElementNS, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterEndElement", _wrap_xmlTextWriterEndElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterFullEndElement", _wrap_xmlTextWriterFullEndElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteFormatElement", _wrap_xmlTextWriterWriteFormatElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteElement", _wrap_xmlTextWriterWriteElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteFormatElementNS", _wrap_xmlTextWriterWriteFormatElementNS, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteElementNS", _wrap_xmlTextWriterWriteElementNS, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteFormatRaw", _wrap_xmlTextWriterWriteFormatRaw, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteRawLen", _wrap_xmlTextWriterWriteRawLen, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteRaw", _wrap_xmlTextWriterWriteRaw, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteFormatString", _wrap_xmlTextWriterWriteFormatString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteString", _wrap_xmlTextWriterWriteString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteBase64", _wrap_xmlTextWriterWriteBase64, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteBinHex", _wrap_xmlTextWriterWriteBinHex, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterStartAttribute", _wrap_xmlTextWriterStartAttribute, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterStartAttributeNS", _wrap_xmlTextWriterStartAttributeNS, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterEndAttribute", _wrap_xmlTextWriterEndAttribute, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteFormatAttribute", _wrap_xmlTextWriterWriteFormatAttribute, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteAttribute", _wrap_xmlTextWriterWriteAttribute, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteFormatAttributeNS", _wrap_xmlTextWriterWriteFormatAttributeNS, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteAttributeNS", _wrap_xmlTextWriterWriteAttributeNS, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterStartPI", _wrap_xmlTextWriterStartPI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterEndPI", _wrap_xmlTextWriterEndPI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteFormatPI", _wrap_xmlTextWriterWriteFormatPI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWritePI", _wrap_xmlTextWriterWritePI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterStartCDATA", _wrap_xmlTextWriterStartCDATA, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterEndCDATA", _wrap_xmlTextWriterEndCDATA, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteFormatCDATA", _wrap_xmlTextWriterWriteFormatCDATA, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteCDATA", _wrap_xmlTextWriterWriteCDATA, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterStartDTD", _wrap_xmlTextWriterStartDTD, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterEndDTD", _wrap_xmlTextWriterEndDTD, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteFormatDTD", _wrap_xmlTextWriterWriteFormatDTD, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteDTD", _wrap_xmlTextWriterWriteDTD, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterStartDTDElement", _wrap_xmlTextWriterStartDTDElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterEndDTDElement", _wrap_xmlTextWriterEndDTDElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteFormatDTDElement", _wrap_xmlTextWriterWriteFormatDTDElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteDTDElement", _wrap_xmlTextWriterWriteDTDElement, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterStartDTDAttlist", _wrap_xmlTextWriterStartDTDAttlist, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterEndDTDAttlist", _wrap_xmlTextWriterEndDTDAttlist, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteFormatDTDAttlist", _wrap_xmlTextWriterWriteFormatDTDAttlist, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteDTDAttlist", _wrap_xmlTextWriterWriteDTDAttlist, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterStartDTDEntity", _wrap_xmlTextWriterStartDTDEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterEndDTDEntity", _wrap_xmlTextWriterEndDTDEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteFormatDTDInternalEntity", _wrap_xmlTextWriterWriteFormatDTDInternalEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteDTDInternalEntity", _wrap_xmlTextWriterWriteDTDInternalEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteDTDExternalEntity", _wrap_xmlTextWriterWriteDTDExternalEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteDTDExternalEntityContents", _wrap_xmlTextWriterWriteDTDExternalEntityContents, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteDTDEntity", _wrap_xmlTextWriterWriteDTDEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterWriteDTDNotation", _wrap_xmlTextWriterWriteDTDNotation, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterSetIndent", _wrap_xmlTextWriterSetIndent, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterSetIndentString", _wrap_xmlTextWriterSetIndentString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterSetQuoteChar", _wrap_xmlTextWriterSetQuoteChar, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterFlush", _wrap_xmlTextWriterFlush, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlTextWriterClose", _wrap_xmlTextWriterClose, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrNewContext", _wrap_xmlXPtrNewContext, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrEval", _wrap_xmlXPtrEval, context);


  /* register classes */
  SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlBuffer"), _exports__xmlBuffer_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlNotation"), _exports__xmlNotation_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlEnumeration"), _exports__xmlEnumeration_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlAttribute"), _exports__xmlAttribute_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlElementContent"), _exports__xmlElementContent_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlElement"), _exports__xmlElement_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlNs"), _exports__xmlNs_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlDtd"), _exports__xmlDtd_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlAttr"), _exports__xmlAttr_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlID"), _exports__xmlID_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlRef"), _exports__xmlRef_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlNode"), _exports__xmlNode_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlDoc"), _exports__xmlDoc_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlDOMWrapCtxt"), _exports__xmlDOMWrapCtxt_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlError"), _exports__xmlError_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlValidCtxt"), _exports__xmlValidCtxt_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlEntity"), _exports__xmlEntity_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlCharEncodingHandler"), _exports__xmlCharEncodingHandler_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlParserInputBuffer"), _exports__xmlParserInputBuffer_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlOutputBuffer"), _exports__xmlOutputBuffer_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlParserInput"), _exports__xmlParserInput_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlParserNodeInfo"), _exports__xmlParserNodeInfo_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlParserNodeInfoSeq"), _exports__xmlParserNodeInfoSeq_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlParserCtxt"), _exports__xmlParserCtxt_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlSAXLocator"), _exports__xmlSAXLocator_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlSAXHandler"), _exports__xmlSAXHandler_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlSAXHandlerV1"), _exports__xmlSAXHandlerV1_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlNodeSet"), _exports__xmlNodeSet_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlXPathObject"), _exports__xmlXPathObject_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlXPathType"), _exports__xmlXPathType_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlXPathVariable"), _exports__xmlXPathVariable_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlXPathFunct"), _exports__xmlXPathFunct_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlXPathAxis"), _exports__xmlXPathAxis_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlXPathContext"), _exports__xmlXPathContext_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlXPathParserContext"), _exports__xmlXPathParserContext_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlChSRange"), _exports__xmlChSRange_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlChLRange"), _exports__xmlChLRange_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlChRangeGroup"), _exports__xmlChRangeGroup_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_htmlElemDesc"), _exports__htmlElemDesc_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_htmlEntityDesc"), _exports__htmlEntityDesc_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlURI"), _exports__xmlURI_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xlinkHandler"), _exports__xlinkHandler_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlSchemaAnnot"), _exports__xmlSchemaAnnot_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlSchemaAttribute"), _exports__xmlSchemaAttribute_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlSchemaAttributeLink"), _exports__xmlSchemaAttributeLink_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlSchemaWildcardNs"), _exports__xmlSchemaWildcardNs_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlSchemaWildcard"), _exports__xmlSchemaWildcard_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlSchemaAttributeGroup"), _exports__xmlSchemaAttributeGroup_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlSchemaTypeLink"), _exports__xmlSchemaTypeLink_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlSchemaFacetLink"), _exports__xmlSchemaFacetLink_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlSchemaType"), _exports__xmlSchemaType_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlSchemaElement"), _exports__xmlSchemaElement_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlSchemaFacet"), _exports__xmlSchemaFacet_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlSchemaNotation"), _exports__xmlSchemaNotation_obj));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlSchema"), _exports__xmlSchema_obj));


  /* create and register namespace objects */
  
}

#if defined(BUILDING_NODE_EXTENSION)
#if (NODE_MODULE_VERSION < 64)
NODE_MODULE(libxml2, libxml2_initialize)
#else
NODE_MODULE_CONTEXT_AWARE(libxml2, libxml2_initialize)
#endif
#endif
