/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (https://www.swig.org).
 * Version 4.1.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 0x040101
#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



#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 temporal objects */
#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ                (SWIG_ERROR)
#define SWIG_OLDOBJ                (SWIG_OK)
#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del 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_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()
#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())
#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(data), size(size), type(type) {};

  ~SwigV8PackedData() {
  };

  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();
  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);
//  v8::Handle<v8::Object> obj = SWIGV8_OBJECT_NEW();
  v8::Local<v8::Object> obj = SWIGV8_OBJECT_NEW();

  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 = sprintf(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__xmlAttribute swig_types[5]
#define SWIGTYPE_p__xmlAutomata swig_types[6]
#define SWIGTYPE_p__xmlAutomataState swig_types[7]
#define SWIGTYPE_p__xmlBuf swig_types[8]
#define SWIGTYPE_p__xmlBuffer swig_types[9]
#define SWIGTYPE_p__xmlCatalog swig_types[10]
#define SWIGTYPE_p__xmlChLRange swig_types[11]
#define SWIGTYPE_p__xmlChRangeGroup swig_types[12]
#define SWIGTYPE_p__xmlChSRange swig_types[13]
#define SWIGTYPE_p__xmlCharEncodingHandler swig_types[14]
#define SWIGTYPE_p__xmlDOMWrapCtxt swig_types[15]
#define SWIGTYPE_p__xmlDict swig_types[16]
#define SWIGTYPE_p__xmlDoc swig_types[17]
#define SWIGTYPE_p__xmlDtd swig_types[18]
#define SWIGTYPE_p__xmlElement swig_types[19]
#define SWIGTYPE_p__xmlElementContent swig_types[20]
#define SWIGTYPE_p__xmlEntity swig_types[21]
#define SWIGTYPE_p__xmlEnumeration swig_types[22]
#define SWIGTYPE_p__xmlError swig_types[23]
#define SWIGTYPE_p__xmlExpCtxt swig_types[24]
#define SWIGTYPE_p__xmlExpNode swig_types[25]
#define SWIGTYPE_p__xmlGlobalState swig_types[26]
#define SWIGTYPE_p__xmlHashTable swig_types[27]
#define SWIGTYPE_p__xmlID swig_types[28]
#define SWIGTYPE_p__xmlLink swig_types[29]
#define SWIGTYPE_p__xmlList swig_types[30]
#define SWIGTYPE_p__xmlLocationSet swig_types[31]
#define SWIGTYPE_p__xmlModule swig_types[32]
#define SWIGTYPE_p__xmlMutex swig_types[33]
#define SWIGTYPE_p__xmlNode swig_types[34]
#define SWIGTYPE_p__xmlNodeSet swig_types[35]
#define SWIGTYPE_p__xmlNotation swig_types[36]
#define SWIGTYPE_p__xmlNs swig_types[37]
#define SWIGTYPE_p__xmlOutputBuffer swig_types[38]
#define SWIGTYPE_p__xmlParserCtxt swig_types[39]
#define SWIGTYPE_p__xmlParserInput swig_types[40]
#define SWIGTYPE_p__xmlParserInputBuffer swig_types[41]
#define SWIGTYPE_p__xmlParserNodeInfo swig_types[42]
#define SWIGTYPE_p__xmlParserNodeInfoSeq swig_types[43]
#define SWIGTYPE_p__xmlPattern swig_types[44]
#define SWIGTYPE_p__xmlRMutex swig_types[45]
#define SWIGTYPE_p__xmlRef swig_types[46]
#define SWIGTYPE_p__xmlRegExecCtxt swig_types[47]
#define SWIGTYPE_p__xmlRegexp swig_types[48]
#define SWIGTYPE_p__xmlRelaxNG swig_types[49]
#define SWIGTYPE_p__xmlRelaxNGParserCtxt swig_types[50]
#define SWIGTYPE_p__xmlRelaxNGValidCtxt swig_types[51]
#define SWIGTYPE_p__xmlSAXHandler swig_types[52]
#define SWIGTYPE_p__xmlSAXHandlerV1 swig_types[53]
#define SWIGTYPE_p__xmlSAXLocator swig_types[54]
#define SWIGTYPE_p__xmlSaveCtxt swig_types[55]
#define SWIGTYPE_p__xmlSchema swig_types[56]
#define SWIGTYPE_p__xmlSchemaAnnot swig_types[57]
#define SWIGTYPE_p__xmlSchemaAttribute swig_types[58]
#define SWIGTYPE_p__xmlSchemaAttributeGroup swig_types[59]
#define SWIGTYPE_p__xmlSchemaAttributeLink swig_types[60]
#define SWIGTYPE_p__xmlSchemaElement swig_types[61]
#define SWIGTYPE_p__xmlSchemaFacet swig_types[62]
#define SWIGTYPE_p__xmlSchemaFacetLink swig_types[63]
#define SWIGTYPE_p__xmlSchemaNotation swig_types[64]
#define SWIGTYPE_p__xmlSchemaParserCtxt swig_types[65]
#define SWIGTYPE_p__xmlSchemaSAXPlug swig_types[66]
#define SWIGTYPE_p__xmlSchemaType swig_types[67]
#define SWIGTYPE_p__xmlSchemaTypeLink swig_types[68]
#define SWIGTYPE_p__xmlSchemaVal swig_types[69]
#define SWIGTYPE_p__xmlSchemaValidCtxt swig_types[70]
#define SWIGTYPE_p__xmlSchemaWildcard swig_types[71]
#define SWIGTYPE_p__xmlSchemaWildcardNs swig_types[72]
#define SWIGTYPE_p__xmlStartTag swig_types[73]
#define SWIGTYPE_p__xmlStreamCtxt swig_types[74]
#define SWIGTYPE_p__xmlURI swig_types[75]
#define SWIGTYPE_p__xmlValidCtxt swig_types[76]
#define SWIGTYPE_p__xmlValidState swig_types[77]
#define SWIGTYPE_p__xmlXPathAxis swig_types[78]
#define SWIGTYPE_p__xmlXPathCompExpr swig_types[79]
#define SWIGTYPE_p__xmlXPathContext swig_types[80]
#define SWIGTYPE_p__xmlXPathFunct swig_types[81]
#define SWIGTYPE_p__xmlXPathObject swig_types[82]
#define SWIGTYPE_p__xmlXPathParserContext swig_types[83]
#define SWIGTYPE_p__xmlXPathType swig_types[84]
#define SWIGTYPE_p__xmlXPathVariable swig_types[85]
#define SWIGTYPE_p_char swig_types[86]
#define SWIGTYPE_p_f_p__xmlEntity_p__xmlNode_p__xmlNode__void swig_types[87]
#define SWIGTYPE_p_f_p__xmlLink__void swig_types[88]
#define SWIGTYPE_p_f_p__xmlNode__void swig_types[89]
#define SWIGTYPE_p_f_p__xmlRegExecCtxt_p_q_const__unsigned_char_p_void_p_void__void swig_types[90]
#define SWIGTYPE_p_f_p__xmlXPathObject_int__int swig_types[91]
#define SWIGTYPE_p_f_p__xmlXPathParserContext_int__void swig_types[92]
#define SWIGTYPE_p_f_p_q_const__char__int swig_types[93]
#define SWIGTYPE_p_f_p_q_const__char__p_char swig_types[94]
#define SWIGTYPE_p_f_p_q_const__char__p_void swig_types[95]
#define SWIGTYPE_p_f_p_q_const__char_p_q_const__char_xmlParserCtxtPtr__p__xmlParserInput swig_types[96]
#define SWIGTYPE_p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer swig_types[97]
#define SWIGTYPE_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer swig_types[98]
#define SWIGTYPE_p_f_p_q_const__void_p_q_const__void__int swig_types[99]
#define SWIGTYPE_p_f_p_q_const__void_p_void__int swig_types[100]
#define SWIGTYPE_p_f_p_unsigned_char__void swig_types[101]
#define SWIGTYPE_p_f_p_unsigned_char_p_int_p_q_const__unsigned_char_p_int__int swig_types[102]
#define SWIGTYPE_p_f_p_void__int swig_types[103]
#define SWIGTYPE_p_f_p_void__p_unsigned_char swig_types[104]
#define SWIGTYPE_p_f_p_void__void swig_types[105]
#define SWIGTYPE_p_f_p_void_p__xmlError__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__char_int__int swig_types[114]
#define SWIGTYPE_p_f_p_void_p_q_const__char_v_______void swig_types[115]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__p_void swig_types[116]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char__void swig_types[117]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int__void swig_types[118]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_int_p__xmlElementContent__void swig_types[119]
#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[120]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_p_q_const__unsigned_char__void swig_types[121]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_p_q_const__unsigned_char__p_f_p__xmlXPathParserContext_int__void swig_types[122]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_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_int_int_p_q_const__unsigned_char_p__xmlEnumeration__void swig_types[124]
#define SWIGTYPE_p_f_p_void_p_q_const__unsigned_char_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_p_q_const__unsigned_char_int_p_p_q_const__unsigned_char_int_int_p_p_q_const__unsigned_char__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_p_q_const__unsigned_char__void swig_types[127]
#define SWIGTYPE_p_f_p_void_p_q_const__xmlChar__p__xmlEntity swig_types[128]
#define SWIGTYPE_p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlParserInput swig_types[129]
#define SWIGTYPE_p_f_p_void_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlXPathObject swig_types[130]
#define SWIGTYPE_p_f_p_void_p_void_p_q_const__unsigned_char__void swig_types[131]
#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[132]
#define SWIGTYPE_p_f_p_void_size_t__p_void swig_types[133]
#define SWIGTYPE_p_f_size_t__p_void swig_types[134]
#define SWIGTYPE_p_f_xmlDOMWrapCtxtPtr_xmlNodePtr_p_q_const__xmlChar_p_q_const__xmlChar__p__xmlNs swig_types[135]
#define SWIGTYPE_p_f_xmlXPathParserContextPtr_xmlXPathObjectPtr__p__xmlXPathObject swig_types[136]
#define SWIGTYPE_p_htmlParserOption swig_types[137]
#define SWIGTYPE_p_htmlStatus swig_types[138]
#define SWIGTYPE_p_int swig_types[139]
#define SWIGTYPE_p_p__xmlDoc swig_types[140]
#define SWIGTYPE_p_p__xmlElementContent swig_types[141]
#define SWIGTYPE_p_p__xmlEnumeration swig_types[142]
#define SWIGTYPE_p_p__xmlNode swig_types[143]
#define SWIGTYPE_p_p__xmlNs swig_types[144]
#define SWIGTYPE_p_p__xmlParserCtxt swig_types[145]
#define SWIGTYPE_p_p__xmlParserInput swig_types[146]
#define SWIGTYPE_p_p__xmlSAXHandler swig_types[147]
#define SWIGTYPE_p_p__xmlSchemaAttributeLink swig_types[148]
#define SWIGTYPE_p_p__xmlSchemaVal swig_types[149]
#define SWIGTYPE_p_p__xmlXPathObject swig_types[150]
#define SWIGTYPE_p_p_char swig_types[151]
#define SWIGTYPE_p_p_f_p__xmlNode__void swig_types[152]
#define SWIGTYPE_p_p_f_p_q_const__char__p_char swig_types[153]
#define SWIGTYPE_p_p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer swig_types[154]
#define SWIGTYPE_p_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer swig_types[155]
#define SWIGTYPE_p_p_f_p_void__void swig_types[156]
#define SWIGTYPE_p_p_f_p_void_p__xmlError__void swig_types[157]
#define SWIGTYPE_p_p_f_p_void_p_q_const__char_v_______void swig_types[158]
#define SWIGTYPE_p_p_f_p_void_size_t__p_void swig_types[159]
#define SWIGTYPE_p_p_f_size_t__p_void swig_types[160]
#define SWIGTYPE_p_p_unsigned_char swig_types[161]
#define SWIGTYPE_p_p_void swig_types[162]
#define SWIGTYPE_p_unsigned_char swig_types[163]
#define SWIGTYPE_p_unsigned_long swig_types[164]
#define SWIGTYPE_p_void swig_types[165]
#define SWIGTYPE_p_xlinkActuate swig_types[166]
#define SWIGTYPE_p_xlinkShow swig_types[167]
#define SWIGTYPE_p_xlinkType swig_types[168]
#define SWIGTYPE_p_xmlAttributeDefault swig_types[169]
#define SWIGTYPE_p_xmlAttributeType swig_types[170]
#define SWIGTYPE_p_xmlBufferAllocationScheme swig_types[171]
#define SWIGTYPE_p_xmlCatalogAllow swig_types[172]
#define SWIGTYPE_p_xmlCatalogPrefer swig_types[173]
#define SWIGTYPE_p_xmlCharEncoding swig_types[174]
#define SWIGTYPE_p_xmlDocProperties swig_types[175]
#define SWIGTYPE_p_xmlElementContentOccur swig_types[176]
#define SWIGTYPE_p_xmlElementContentType swig_types[177]
#define SWIGTYPE_p_xmlElementType swig_types[178]
#define SWIGTYPE_p_xmlElementTypeVal swig_types[179]
#define SWIGTYPE_p_xmlEntityType swig_types[180]
#define SWIGTYPE_p_xmlErrorDomain swig_types[181]
#define SWIGTYPE_p_xmlErrorLevel swig_types[182]
#define SWIGTYPE_p_xmlExpNodeType swig_types[183]
#define SWIGTYPE_p_xmlFeature swig_types[184]
#define SWIGTYPE_p_xmlModuleOption swig_types[185]
#define SWIGTYPE_p_xmlParserErrors swig_types[186]
#define SWIGTYPE_p_xmlParserInputState swig_types[187]
#define SWIGTYPE_p_xmlParserMode swig_types[188]
#define SWIGTYPE_p_xmlParserOption swig_types[189]
#define SWIGTYPE_p_xmlParserSeverities swig_types[190]
#define SWIGTYPE_p_xmlPatternFlags swig_types[191]
#define SWIGTYPE_p_xmlRelaxNGParserFlag swig_types[192]
#define SWIGTYPE_p_xmlRelaxNGValidErr swig_types[193]
#define SWIGTYPE_p_xmlSaveOption swig_types[194]
#define SWIGTYPE_p_xmlSchemaContentType swig_types[195]
#define SWIGTYPE_p_xmlSchemaTypeType swig_types[196]
#define SWIGTYPE_p_xmlSchemaValType swig_types[197]
#define SWIGTYPE_p_xmlSchemaValidError swig_types[198]
#define SWIGTYPE_p_xmlSchemaValidOption swig_types[199]
#define SWIGTYPE_p_xmlSchemaWhitespaceValueType swig_types[200]
#define SWIGTYPE_p_xmlXPathError swig_types[201]
#define SWIGTYPE_p_xmlXPathObjectType swig_types[202]
static swig_type_info *swig_types[204];
static swig_module_info swig_module = {swig_types, 203, 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 = floor(x);
   double cx = ceil(x);
   double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
   if ((errno == EDOM) || (errno == ERANGE)) {
     errno = 0;
   } else {
     double summ, reps, diff;
     if (rd < x) {
       diff = x - rd;
     } else if (rd > x) {
       diff = rd - x;
     } else {
       return 1;
     }
     summ = rd + x;
     reps = diff/summ;
     if (reps < 8*DBL_EPSILON) {
       *d = rd;
       return 1;
     }
   }
  }
  return 0;
}


SWIGINTERN
int SWIG_AsVal_unsigned_SS_long (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;
}


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


SWIGINTERNINLINE SWIGV8_VALUE
SWIG_From_unsigned_SS_int  (unsigned int value)
{    
  return SWIG_From_unsigned_SS_long  (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
}


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


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__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__xmlCharEncodingHandler_clientData;
SWIGV8_ClientData _exports__xlinkHandler_clientData;
SWIGV8_ClientData _exports__xmlParserInputBuffer_clientData;
SWIGV8_ClientData _exports__xmlOutputBuffer_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__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;
SWIGV8_ClientData _exports__xmlLocationSet_clientData;


static SwigV8ReturnValue _wrap_setDebugEnable(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if(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) 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) 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) 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) 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) 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) 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 _wrap_ATTRIBUTE_DESTRUCTOR(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 _wrap_HAVE_ARPA_INET_H(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 _wrap_HAVE_ARPA_NAMESER_H(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 _wrap_HAVE_CTYPE_H(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 _wrap_HAVE_DIRENT_H(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 _wrap_HAVE_DLFCN_H(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 _wrap_HAVE_ERRNO_H(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 _wrap_HAVE_FCNTL_H(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 _wrap_HAVE_FLOAT_H(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 _wrap_HAVE_FPRINTF(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 _wrap_HAVE_FTIME(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 _wrap_HAVE_GETTIMEOFDAY(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 _wrap_HAVE_INTTYPES_H(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 _wrap_HAVE_ISASCII(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 _wrap_HAVE_LIMITS_H(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 _wrap_HAVE_LOCALTIME(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 _wrap_HAVE_MATH_H(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 _wrap_HAVE_MEMORY_H(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 _wrap_HAVE_MMAP(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 _wrap_HAVE_MUNMAP(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 _wrap_HAVE_NETDB_H(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 _wrap_HAVE_NETINET_IN_H(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 _wrap_HAVE_POLL_H(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 _wrap_HAVE_PRINTF(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 _wrap_HAVE_PUTENV(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 _wrap_HAVE_RAND(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 _wrap_HAVE_RESOLV_H(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 _wrap_HAVE_SIGNAL(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 _wrap_HAVE_SIGNAL_H(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 _wrap_HAVE_SNPRINTF(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 _wrap_HAVE_SPRINTF(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 _wrap_HAVE_SRAND(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 _wrap_HAVE_SSCANF(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 _wrap_HAVE_STAT(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 _wrap_HAVE_STDARG_H(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 _wrap_HAVE_STDINT_H(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 _wrap_HAVE_STDLIB_H(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 _wrap_HAVE_STRFTIME(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 _wrap_HAVE_STRINGS_H(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 _wrap_HAVE_STRING_H(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 _wrap_HAVE_SYS_MMAN_H(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 _wrap_HAVE_SYS_SELECT_H(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 _wrap_HAVE_SYS_SOCKET_H(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 _wrap_HAVE_SYS_STAT_H(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 _wrap_HAVE_SYS_TIMEB_H(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 _wrap_HAVE_SYS_TIME_H(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 _wrap_HAVE_SYS_TYPES_H(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 _wrap_HAVE_TIME(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 _wrap_HAVE_TIME_H(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 _wrap_HAVE_VFPRINTF(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 _wrap_HAVE_VSNPRINTF(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 _wrap_HAVE_VSPRINTF(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 _wrap_LT_OBJDIR(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_FromCharPtr((const char *)".libs/");
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


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


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


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


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


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


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


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


static SwigV8ReturnValue _wrap_STDC_HEADERS(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 _wrap_VA_LIST_IS_ARRAY(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 _wrap_VERSION(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_FromCharPtr((const char *)"2.9.12");
  
  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) 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_LIBXML_DOTTED_VERSION(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_FromCharPtr((const char *)"2.9.12");
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


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


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


static SwigV8ReturnValue _wrap_LIBXML_VERSION_EXTRA(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 _wrap_LIBXML_MODULE_EXTENSION(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_FromCharPtr((const char *)".so");
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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 SwigV8ReturnValue _wrap_BASE_BUFFER_SIZE(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 _wrap_XML_BUFFER_ALLOC_DOUBLEIT(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 _wrap_XML_BUFFER_ALLOC_EXACT(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 _wrap_XML_BUFFER_ALLOC_IMMUTABLE(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 _wrap_XML_BUFFER_ALLOC_IO(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 _wrap_XML_BUFFER_ALLOC_HYBRID(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 _wrap_XML_BUFFER_ALLOC_BOUNDED(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) 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) 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) 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) 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) 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 _wrap_XML_ELEMENT_NODE(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 _wrap_XML_ATTRIBUTE_NODE(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 _wrap_XML_TEXT_NODE(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 _wrap_XML_CDATA_SECTION_NODE(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 _wrap_XML_ENTITY_REF_NODE(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 _wrap_XML_ENTITY_NODE(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 _wrap_XML_PI_NODE(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 _wrap_XML_COMMENT_NODE(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 _wrap_XML_DOCUMENT_NODE(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 _wrap_XML_DOCUMENT_TYPE_NODE(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 _wrap_XML_DOCUMENT_FRAG_NODE(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 _wrap_XML_NOTATION_NODE(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 _wrap_XML_HTML_DOCUMENT_NODE(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 _wrap_XML_DTD_NODE(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 _wrap_XML_ELEMENT_DECL(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 _wrap_XML_ATTRIBUTE_DECL(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 _wrap_XML_ENTITY_DECL(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 _wrap_XML_NAMESPACE_DECL(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 _wrap_XML_XINCLUDE_START(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 _wrap_XML_XINCLUDE_END(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 _wrap_XML_DOCB_DOCUMENT_NODE(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XML_DOCB_DOCUMENT_NODE));
  
  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) 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 _wrap_XML_ATTRIBUTE_CDATA(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 _wrap_XML_ATTRIBUTE_ID(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 _wrap_XML_ATTRIBUTE_IDREF(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 _wrap_XML_ATTRIBUTE_IDREFS(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 _wrap_XML_ATTRIBUTE_ENTITY(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 _wrap_XML_ATTRIBUTE_ENTITIES(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 _wrap_XML_ATTRIBUTE_NMTOKEN(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 _wrap_XML_ATTRIBUTE_NMTOKENS(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 _wrap_XML_ATTRIBUTE_ENUMERATION(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 _wrap_XML_ATTRIBUTE_NOTATION(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 _wrap_XML_ATTRIBUTE_NONE(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 _wrap_XML_ATTRIBUTE_REQUIRED(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 _wrap_XML_ATTRIBUTE_IMPLIED(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 _wrap_XML_ATTRIBUTE_FIXED(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) 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) 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 _wrap_XML_ELEMENT_CONTENT_PCDATA(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 _wrap_XML_ELEMENT_CONTENT_ELEMENT(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 _wrap_XML_ELEMENT_CONTENT_SEQ(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 _wrap_XML_ELEMENT_CONTENT_OR(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 _wrap_XML_ELEMENT_CONTENT_ONCE(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 _wrap_XML_ELEMENT_CONTENT_OPT(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 _wrap_XML_ELEMENT_CONTENT_MULT(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 _wrap_XML_ELEMENT_CONTENT_PLUS(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) 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 _wrap_XML_ELEMENT_TYPE_UNDEFINED(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 _wrap_XML_ELEMENT_TYPE_EMPTY(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 _wrap_XML_ELEMENT_TYPE_ANY(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 _wrap_XML_ELEMENT_TYPE_MIXED(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 _wrap_XML_ELEMENT_TYPE_ELEMENT(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 SwigV8ReturnValue _wrap_xmlInitializeDict(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if(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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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_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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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 _wrap_xmlExpFreeCtxt(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlExpCtxtPtr arg1 = (xmlExpCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlExpFreeCtxt.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlExpCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlExpFreeCtxt" "', argument " "1"" of type '" "xmlExpCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlExpCtxtPtr >(argp1);
  xmlExpFreeCtxt(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlExpNewCtxt(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 ;
  xmlExpCtxtPtr result;
  
  if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlExpNewCtxt.");
  
  ecode1 = SWIG_AsVal_int(args[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlExpNewCtxt" "', 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 '" "xmlExpNewCtxt" "', argument " "2"" of type '" "xmlDictPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlDictPtr >(argp2);
  result = (xmlExpCtxtPtr)xmlExpNewCtxt(arg1,arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlExpCtxt, 0 |  0 );
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


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


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


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


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


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


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


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


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


static void _wrap_forbiddenExp_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlExpNodePtr arg1 = (xmlExpNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(value, &argp1,SWIGTYPE_p__xmlExpNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "forbiddenExp_set" "', argument " "1"" of type '" "xmlExpNodePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlExpNodePtr >(argp1);
  forbiddenExp = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_forbiddenExp_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlExpNodePtr result;
  
  result = (xmlExpNodePtr)forbiddenExp;
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlExpNode, 0 |  0 );
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static void _wrap_emptyExp_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlExpNodePtr arg1 = (xmlExpNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(value, &argp1,SWIGTYPE_p__xmlExpNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptyExp_set" "', argument " "1"" of type '" "xmlExpNodePtr""'"); 
  }
  arg1 = reinterpret_cast< xmlExpNodePtr >(argp1);
  emptyExp = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_emptyExp_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlExpNodePtr result;
  
  result = (xmlExpNodePtr)emptyExp;
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlExpNode, 0 |  0 );
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


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


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


static SwigV8ReturnValue _wrap_xmlExpParse(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlExpCtxtPtr arg1 = (xmlExpCtxtPtr) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  size_t size2 = 0 ;
  int alloc2 = 0 ;
  xmlExpNodePtr result;
  
  if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlExpParse.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlExpCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlExpParse" "', argument " "1"" of type '" "xmlExpCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlExpCtxtPtr >(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 '" "xmlExpParse" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }
  result = (xmlExpNodePtr)xmlExpParse(arg1,(char const *)arg2);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlExpNode, 0 |  0 );
  
  // free(arg2);
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlExpNewAtom(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlExpCtxtPtr arg1 = (xmlExpCtxtPtr) 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 ;
  xmlExpNodePtr result;
  
  if(args.Length() != 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlExpNewAtom.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlExpCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlExpNewAtom" "', argument " "1"" of type '" "xmlExpCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlExpCtxtPtr >(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 '" "xmlExpNewAtom" "', 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 '" "xmlExpNewAtom" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  result = (xmlExpNodePtr)xmlExpNewAtom(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlExpNode, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlExpNewOr(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlExpCtxtPtr arg1 = (xmlExpCtxtPtr) 0 ;
  xmlExpNodePtr arg2 = (xmlExpNodePtr) 0 ;
  xmlExpNodePtr arg3 = (xmlExpNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  xmlExpNodePtr result;
  
  if(args.Length() != 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlExpNewOr.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlExpCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlExpNewOr" "', argument " "1"" of type '" "xmlExpCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlExpCtxtPtr >(argp1);
  res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlExpNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlExpNewOr" "', argument " "2"" of type '" "xmlExpNodePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlExpNodePtr >(argp2);
  res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlExpNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlExpNewOr" "', argument " "3"" of type '" "xmlExpNodePtr""'"); 
  }
  arg3 = reinterpret_cast< xmlExpNodePtr >(argp3);
  result = (xmlExpNodePtr)xmlExpNewOr(arg1,arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlExpNode, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlExpNewSeq(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlExpCtxtPtr arg1 = (xmlExpCtxtPtr) 0 ;
  xmlExpNodePtr arg2 = (xmlExpNodePtr) 0 ;
  xmlExpNodePtr arg3 = (xmlExpNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  xmlExpNodePtr result;
  
  if(args.Length() != 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlExpNewSeq.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlExpCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlExpNewSeq" "', argument " "1"" of type '" "xmlExpCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlExpCtxtPtr >(argp1);
  res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlExpNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlExpNewSeq" "', argument " "2"" of type '" "xmlExpNodePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlExpNodePtr >(argp2);
  res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlExpNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlExpNewSeq" "', argument " "3"" of type '" "xmlExpNodePtr""'"); 
  }
  arg3 = reinterpret_cast< xmlExpNodePtr >(argp3);
  result = (xmlExpNodePtr)xmlExpNewSeq(arg1,arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlExpNode, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlExpNewRange(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlExpCtxtPtr arg1 = (xmlExpCtxtPtr) 0 ;
  xmlExpNodePtr arg2 = (xmlExpNodePtr) 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  xmlExpNodePtr result;
  
  if(args.Length() != 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlExpNewRange.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlExpCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlExpNewRange" "', argument " "1"" of type '" "xmlExpCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlExpCtxtPtr >(argp1);
  res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlExpNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlExpNewRange" "', argument " "2"" of type '" "xmlExpNodePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlExpNodePtr >(argp2);
  ecode3 = SWIG_AsVal_int(args[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xmlExpNewRange" "', 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 '" "xmlExpNewRange" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (xmlExpNodePtr)xmlExpNewRange(arg1,arg2,arg3,arg4);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlExpNode, 0 |  0 );
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


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


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


static SwigV8ReturnValue _wrap_xmlExpGetLanguage(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlExpCtxtPtr arg1 = (xmlExpCtxtPtr) 0 ;
  xmlExpNodePtr arg2 = (xmlExpNodePtr) 0 ;
  xmlChar **arg3 = (xmlChar **) 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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlExpGetLanguage.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlExpCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlExpGetLanguage" "', argument " "1"" of type '" "xmlExpCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlExpCtxtPtr >(argp1);
  res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlExpNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlExpGetLanguage" "', argument " "2"" of type '" "xmlExpNodePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlExpNodePtr >(argp2);
  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 '" "xmlExpGetLanguage" "', 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 '" "xmlExpGetLanguage" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (int)xmlExpGetLanguage(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_xmlExpGetStart(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlExpCtxtPtr arg1 = (xmlExpCtxtPtr) 0 ;
  xmlExpNodePtr arg2 = (xmlExpNodePtr) 0 ;
  xmlChar **arg3 = (xmlChar **) 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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlExpGetStart.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlExpCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlExpGetStart" "', argument " "1"" of type '" "xmlExpCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlExpCtxtPtr >(argp1);
  res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlExpNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlExpGetStart" "', argument " "2"" of type '" "xmlExpNodePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlExpNodePtr >(argp2);
  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 '" "xmlExpGetStart" "', 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 '" "xmlExpGetStart" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (int)xmlExpGetStart(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_xmlExpStringDerive(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlExpCtxtPtr arg1 = (xmlExpCtxtPtr) 0 ;
  xmlExpNodePtr arg2 = (xmlExpNodePtr) 0 ;
  xmlChar *arg3 = (xmlChar *) 0 ;
  int arg4 ;
  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 val4 ;
  int ecode4 = 0 ;
  xmlExpNodePtr result;
  
  if(args.Length() != 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlExpStringDerive.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlExpCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlExpStringDerive" "', argument " "1"" of type '" "xmlExpCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlExpCtxtPtr >(argp1);
  res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlExpNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlExpStringDerive" "', argument " "2"" of type '" "xmlExpNodePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlExpNodePtr >(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 '" "xmlExpStringDerive" "', 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 '" "xmlExpStringDerive" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (xmlExpNodePtr)xmlExpStringDerive(arg1,arg2,(unsigned char const *)arg3,arg4);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlExpNode, 0 |  0 );
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlExpExpDerive(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlExpCtxtPtr arg1 = (xmlExpCtxtPtr) 0 ;
  xmlExpNodePtr arg2 = (xmlExpNodePtr) 0 ;
  xmlExpNodePtr arg3 = (xmlExpNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  xmlExpNodePtr result;
  
  if(args.Length() != 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlExpExpDerive.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlExpCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlExpExpDerive" "', argument " "1"" of type '" "xmlExpCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlExpCtxtPtr >(argp1);
  res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlExpNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlExpExpDerive" "', argument " "2"" of type '" "xmlExpNodePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlExpNodePtr >(argp2);
  res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlExpNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlExpExpDerive" "', argument " "3"" of type '" "xmlExpNodePtr""'"); 
  }
  arg3 = reinterpret_cast< xmlExpNodePtr >(argp3);
  result = (xmlExpNodePtr)xmlExpExpDerive(arg1,arg2,arg3);
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlExpNode, 0 |  0 );
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlExpSubsume(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlExpCtxtPtr arg1 = (xmlExpCtxtPtr) 0 ;
  xmlExpNodePtr arg2 = (xmlExpNodePtr) 0 ;
  xmlExpNodePtr arg3 = (xmlExpNodePtr) 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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlExpSubsume.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlExpCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlExpSubsume" "', argument " "1"" of type '" "xmlExpCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlExpCtxtPtr >(argp1);
  res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlExpNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlExpSubsume" "', argument " "2"" of type '" "xmlExpNodePtr""'"); 
  }
  arg2 = reinterpret_cast< xmlExpNodePtr >(argp2);
  res3 = SWIG_ConvertPtr(args[2], &argp3,SWIGTYPE_p__xmlExpNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xmlExpSubsume" "', argument " "3"" of type '" "xmlExpNodePtr""'"); 
  }
  arg3 = reinterpret_cast< xmlExpNodePtr >(argp3);
  result = (int)xmlExpSubsume(arg1,arg2,arg3);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


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


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) 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) 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) 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__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) 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) 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) 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) 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 _wrap_XML_DOC_WELLFORMED(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 _wrap_XML_DOC_NSVALID(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 _wrap_XML_DOC_OLD10(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 _wrap_XML_DOC_DTDVALID(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 _wrap_XML_DOC_XINCLUDE(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 _wrap_XML_DOC_USERBUILT(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 _wrap_XML_DOC_INTERNAL(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 _wrap_XML_DOC_HTML(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) 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) 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_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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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_xmlNewGlobalNs(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 ;
  xmlNsPtr result;
  
  if(args.Length() != 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNewGlobalNs.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlNewGlobalNs', 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 '" "xmlNewGlobalNs" "', 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 '" "xmlNewGlobalNs" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }
  result = (xmlNsPtr)xmlNewGlobalNs(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_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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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 ;
  
  if(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;
  xmlSetTreeDoc(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  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 ;
  
  if(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;
  xmlSetListDoc(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  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) 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) 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_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) 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) 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) 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) 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) 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) 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_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) 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) 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) 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) 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) 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) 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) 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) 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) 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 ;
  
  if(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);
  }
  xmlNodeSetContent(arg1,(unsigned char const *)arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  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 ;
  
  if(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);
  xmlNodeSetContentLen(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  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 ;
  
  if(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);
  }
  xmlNodeAddContent(arg1,(unsigned char const *)arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  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 ;
  
  if(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);
  xmlNodeAddContentLen(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  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) 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) 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) 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) 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) 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 ;
  
  if(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);
  }
  xmlNodeSetLang(arg1,(unsigned char const *)arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  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 ;
  
  if(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);
  xmlNodeSetSpacePreserve(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  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) 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 ;
  
  if(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);
  }
  xmlNodeSetBase(arg1,(unsigned char const *)arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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_xmlHashCreate(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  xmlHashTablePtr result;
  
  if(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) 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) 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) 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_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) 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) 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_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) 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) 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_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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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_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) 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) 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) 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) 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) 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) 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 _wrap_XML_ERR_NONE(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 _wrap_XML_ERR_WARNING(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 _wrap_XML_ERR_ERROR(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 _wrap_XML_ERR_FATAL(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 _wrap_XML_FROM_NONE(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 _wrap_XML_FROM_PARSER(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 _wrap_XML_FROM_TREE(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 _wrap_XML_FROM_NAMESPACE(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 _wrap_XML_FROM_DTD(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 _wrap_XML_FROM_HTML(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 _wrap_XML_FROM_MEMORY(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 _wrap_XML_FROM_OUTPUT(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 _wrap_XML_FROM_IO(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 _wrap_XML_FROM_FTP(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 _wrap_XML_FROM_HTTP(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 _wrap_XML_FROM_XINCLUDE(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 _wrap_XML_FROM_XPATH(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 _wrap_XML_FROM_XPOINTER(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 _wrap_XML_FROM_REGEXP(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 _wrap_XML_FROM_DATATYPE(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 _wrap_XML_FROM_SCHEMASP(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 _wrap_XML_FROM_SCHEMASV(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 _wrap_XML_FROM_RELAXNGP(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 _wrap_XML_FROM_RELAXNGV(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 _wrap_XML_FROM_CATALOG(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 _wrap_XML_FROM_C14N(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 _wrap_XML_FROM_XSLT(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 _wrap_XML_FROM_VALID(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 _wrap_XML_FROM_CHECK(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 _wrap_XML_FROM_WRITER(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 _wrap_XML_FROM_MODULE(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 _wrap_XML_FROM_I18N(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 _wrap_XML_FROM_SCHEMATRONV(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 _wrap_XML_FROM_BUFFER(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 _wrap_XML_FROM_URI(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) 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 _wrap_XML_ERR_OK(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 _wrap_XML_ERR_INTERNAL_ERROR(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 _wrap_XML_ERR_NO_MEMORY(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 _wrap_XML_ERR_DOCUMENT_START(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 _wrap_XML_ERR_DOCUMENT_EMPTY(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 _wrap_XML_ERR_DOCUMENT_END(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 _wrap_XML_ERR_INVALID_HEX_CHARREF(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 _wrap_XML_ERR_INVALID_DEC_CHARREF(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 _wrap_XML_ERR_INVALID_CHARREF(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 _wrap_XML_ERR_INVALID_CHAR(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 _wrap_XML_ERR_CHARREF_AT_EOF(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 _wrap_XML_ERR_CHARREF_IN_PROLOG(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 _wrap_XML_ERR_CHARREF_IN_EPILOG(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 _wrap_XML_ERR_CHARREF_IN_DTD(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 _wrap_XML_ERR_ENTITYREF_AT_EOF(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 _wrap_XML_ERR_ENTITYREF_IN_PROLOG(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 _wrap_XML_ERR_ENTITYREF_IN_EPILOG(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 _wrap_XML_ERR_ENTITYREF_IN_DTD(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 _wrap_XML_ERR_PEREF_AT_EOF(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 _wrap_XML_ERR_PEREF_IN_PROLOG(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 _wrap_XML_ERR_PEREF_IN_EPILOG(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 _wrap_XML_ERR_PEREF_IN_INT_SUBSET(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 _wrap_XML_ERR_ENTITYREF_NO_NAME(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 _wrap_XML_ERR_ENTITYREF_SEMICOL_MISSING(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 _wrap_XML_ERR_PEREF_NO_NAME(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 _wrap_XML_ERR_PEREF_SEMICOL_MISSING(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 _wrap_XML_ERR_UNDECLARED_ENTITY(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 _wrap_XML_WAR_UNDECLARED_ENTITY(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 _wrap_XML_ERR_UNPARSED_ENTITY(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 _wrap_XML_ERR_ENTITY_IS_EXTERNAL(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 _wrap_XML_ERR_ENTITY_IS_PARAMETER(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 _wrap_XML_ERR_UNKNOWN_ENCODING(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 _wrap_XML_ERR_UNSUPPORTED_ENCODING(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 _wrap_XML_ERR_STRING_NOT_STARTED(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 _wrap_XML_ERR_STRING_NOT_CLOSED(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 _wrap_XML_ERR_NS_DECL_ERROR(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 _wrap_XML_ERR_ENTITY_NOT_STARTED(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 _wrap_XML_ERR_ENTITY_NOT_FINISHED(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 _wrap_XML_ERR_LT_IN_ATTRIBUTE(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 _wrap_XML_ERR_ATTRIBUTE_NOT_STARTED(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 _wrap_XML_ERR_ATTRIBUTE_NOT_FINISHED(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 _wrap_XML_ERR_ATTRIBUTE_WITHOUT_VALUE(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 _wrap_XML_ERR_ATTRIBUTE_REDEFINED(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 _wrap_XML_ERR_LITERAL_NOT_STARTED(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 _wrap_XML_ERR_LITERAL_NOT_FINISHED(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 _wrap_XML_ERR_COMMENT_NOT_FINISHED(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 _wrap_XML_ERR_PI_NOT_STARTED(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 _wrap_XML_ERR_PI_NOT_FINISHED(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 _wrap_XML_ERR_NOTATION_NOT_STARTED(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 _wrap_XML_ERR_NOTATION_NOT_FINISHED(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 _wrap_XML_ERR_ATTLIST_NOT_STARTED(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 _wrap_XML_ERR_ATTLIST_NOT_FINISHED(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 _wrap_XML_ERR_MIXED_NOT_STARTED(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 _wrap_XML_ERR_MIXED_NOT_FINISHED(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 _wrap_XML_ERR_ELEMCONTENT_NOT_STARTED(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 _wrap_XML_ERR_ELEMCONTENT_NOT_FINISHED(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 _wrap_XML_ERR_XMLDECL_NOT_STARTED(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 _wrap_XML_ERR_XMLDECL_NOT_FINISHED(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 _wrap_XML_ERR_CONDSEC_NOT_STARTED(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 _wrap_XML_ERR_CONDSEC_NOT_FINISHED(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 _wrap_XML_ERR_EXT_SUBSET_NOT_FINISHED(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 _wrap_XML_ERR_DOCTYPE_NOT_FINISHED(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 _wrap_XML_ERR_MISPLACED_CDATA_END(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 _wrap_XML_ERR_CDATA_NOT_FINISHED(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 _wrap_XML_ERR_RESERVED_XML_NAME(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 _wrap_XML_ERR_SPACE_REQUIRED(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 _wrap_XML_ERR_SEPARATOR_REQUIRED(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 _wrap_XML_ERR_NMTOKEN_REQUIRED(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 _wrap_XML_ERR_NAME_REQUIRED(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 _wrap_XML_ERR_PCDATA_REQUIRED(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 _wrap_XML_ERR_URI_REQUIRED(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 _wrap_XML_ERR_PUBID_REQUIRED(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 _wrap_XML_ERR_LT_REQUIRED(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 _wrap_XML_ERR_GT_REQUIRED(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 _wrap_XML_ERR_LTSLASH_REQUIRED(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 _wrap_XML_ERR_EQUAL_REQUIRED(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 _wrap_XML_ERR_TAG_NAME_MISMATCH(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 _wrap_XML_ERR_TAG_NOT_FINISHED(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 _wrap_XML_ERR_STANDALONE_VALUE(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 _wrap_XML_ERR_ENCODING_NAME(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 _wrap_XML_ERR_HYPHEN_IN_COMMENT(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 _wrap_XML_ERR_INVALID_ENCODING(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 _wrap_XML_ERR_EXT_ENTITY_STANDALONE(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 _wrap_XML_ERR_CONDSEC_INVALID(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 _wrap_XML_ERR_VALUE_REQUIRED(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 _wrap_XML_ERR_NOT_WELL_BALANCED(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 _wrap_XML_ERR_EXTRA_CONTENT(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 _wrap_XML_ERR_ENTITY_CHAR_ERROR(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 _wrap_XML_ERR_ENTITY_PE_INTERNAL(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 _wrap_XML_ERR_ENTITY_LOOP(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 _wrap_XML_ERR_ENTITY_BOUNDARY(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 _wrap_XML_ERR_INVALID_URI(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 _wrap_XML_ERR_URI_FRAGMENT(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 _wrap_XML_WAR_CATALOG_PI(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 _wrap_XML_ERR_NO_DTD(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 _wrap_XML_ERR_CONDSEC_INVALID_KEYWORD(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 _wrap_XML_ERR_VERSION_MISSING(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 _wrap_XML_WAR_UNKNOWN_VERSION(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 _wrap_XML_WAR_LANG_VALUE(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 _wrap_XML_WAR_NS_URI(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 _wrap_XML_WAR_NS_URI_RELATIVE(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 _wrap_XML_ERR_MISSING_ENCODING(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 _wrap_XML_WAR_SPACE_VALUE(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 _wrap_XML_ERR_NOT_STANDALONE(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 _wrap_XML_ERR_ENTITY_PROCESSING(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 _wrap_XML_ERR_NOTATION_PROCESSING(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 _wrap_XML_WAR_NS_COLUMN(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 _wrap_XML_WAR_ENTITY_REDEFINED(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 _wrap_XML_ERR_UNKNOWN_VERSION(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 _wrap_XML_ERR_VERSION_MISMATCH(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 _wrap_XML_ERR_NAME_TOO_LONG(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 _wrap_XML_ERR_USER_STOP(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 _wrap_XML_NS_ERR_XML_NAMESPACE(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 _wrap_XML_NS_ERR_UNDEFINED_NAMESPACE(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 _wrap_XML_NS_ERR_QNAME(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 _wrap_XML_NS_ERR_ATTRIBUTE_REDEFINED(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 _wrap_XML_NS_ERR_EMPTY(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 _wrap_XML_NS_ERR_COLON(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 _wrap_XML_DTD_ATTRIBUTE_DEFAULT(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 _wrap_XML_DTD_ATTRIBUTE_REDEFINED(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 _wrap_XML_DTD_ATTRIBUTE_VALUE(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 _wrap_XML_DTD_CONTENT_ERROR(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 _wrap_XML_DTD_CONTENT_MODEL(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 _wrap_XML_DTD_CONTENT_NOT_DETERMINIST(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 _wrap_XML_DTD_DIFFERENT_PREFIX(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 _wrap_XML_DTD_ELEM_DEFAULT_NAMESPACE(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 _wrap_XML_DTD_ELEM_NAMESPACE(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 _wrap_XML_DTD_ELEM_REDEFINED(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 _wrap_XML_DTD_EMPTY_NOTATION(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 _wrap_XML_DTD_ENTITY_TYPE(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 _wrap_XML_DTD_ID_FIXED(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 _wrap_XML_DTD_ID_REDEFINED(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 _wrap_XML_DTD_ID_SUBSET(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 _wrap_XML_DTD_INVALID_CHILD(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 _wrap_XML_DTD_INVALID_DEFAULT(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 _wrap_XML_DTD_LOAD_ERROR(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 _wrap_XML_DTD_MISSING_ATTRIBUTE(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 _wrap_XML_DTD_MIXED_CORRUPT(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 _wrap_XML_DTD_MULTIPLE_ID(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 _wrap_XML_DTD_NO_DOC(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 _wrap_XML_DTD_NO_DTD(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 _wrap_XML_DTD_NO_ELEM_NAME(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 _wrap_XML_DTD_NO_PREFIX(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 _wrap_XML_DTD_NO_ROOT(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 _wrap_XML_DTD_NOTATION_REDEFINED(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 _wrap_XML_DTD_NOTATION_VALUE(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 _wrap_XML_DTD_NOT_EMPTY(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 _wrap_XML_DTD_NOT_PCDATA(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 _wrap_XML_DTD_NOT_STANDALONE(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 _wrap_XML_DTD_ROOT_NAME(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 _wrap_XML_DTD_STANDALONE_WHITE_SPACE(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 _wrap_XML_DTD_UNKNOWN_ATTRIBUTE(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 _wrap_XML_DTD_UNKNOWN_ELEM(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 _wrap_XML_DTD_UNKNOWN_ENTITY(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 _wrap_XML_DTD_UNKNOWN_ID(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 _wrap_XML_DTD_UNKNOWN_NOTATION(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 _wrap_XML_DTD_STANDALONE_DEFAULTED(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 _wrap_XML_DTD_XMLID_VALUE(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 _wrap_XML_DTD_XMLID_TYPE(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 _wrap_XML_DTD_DUP_TOKEN(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 _wrap_XML_HTML_STRUCURE_ERROR(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 _wrap_XML_HTML_UNKNOWN_TAG(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 _wrap_XML_RNGP_ANYNAME_ATTR_ANCESTOR(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 _wrap_XML_RNGP_ATTR_CONFLICT(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 _wrap_XML_RNGP_ATTRIBUTE_CHILDREN(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 _wrap_XML_RNGP_ATTRIBUTE_CONTENT(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 _wrap_XML_RNGP_ATTRIBUTE_EMPTY(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 _wrap_XML_RNGP_ATTRIBUTE_NOOP(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 _wrap_XML_RNGP_CHOICE_CONTENT(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 _wrap_XML_RNGP_CHOICE_EMPTY(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 _wrap_XML_RNGP_CREATE_FAILURE(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 _wrap_XML_RNGP_DATA_CONTENT(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 _wrap_XML_RNGP_DEF_CHOICE_AND_INTERLEAVE(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 _wrap_XML_RNGP_DEFINE_CREATE_FAILED(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 _wrap_XML_RNGP_DEFINE_EMPTY(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 _wrap_XML_RNGP_DEFINE_MISSING(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 _wrap_XML_RNGP_DEFINE_NAME_MISSING(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 _wrap_XML_RNGP_ELEM_CONTENT_EMPTY(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 _wrap_XML_RNGP_ELEM_CONTENT_ERROR(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 _wrap_XML_RNGP_ELEMENT_EMPTY(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 _wrap_XML_RNGP_ELEMENT_CONTENT(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 _wrap_XML_RNGP_ELEMENT_NAME(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 _wrap_XML_RNGP_ELEMENT_NO_CONTENT(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 _wrap_XML_RNGP_ELEM_TEXT_CONFLICT(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 _wrap_XML_RNGP_EMPTY(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 _wrap_XML_RNGP_EMPTY_CONSTRUCT(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 _wrap_XML_RNGP_EMPTY_CONTENT(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 _wrap_XML_RNGP_EMPTY_NOT_EMPTY(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 _wrap_XML_RNGP_ERROR_TYPE_LIB(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 _wrap_XML_RNGP_EXCEPT_EMPTY(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 _wrap_XML_RNGP_EXCEPT_MISSING(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 _wrap_XML_RNGP_EXCEPT_MULTIPLE(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 _wrap_XML_RNGP_EXCEPT_NO_CONTENT(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 _wrap_XML_RNGP_EXTERNALREF_EMTPY(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 _wrap_XML_RNGP_EXTERNAL_REF_FAILURE(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 _wrap_XML_RNGP_EXTERNALREF_RECURSE(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 _wrap_XML_RNGP_FORBIDDEN_ATTRIBUTE(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 _wrap_XML_RNGP_FOREIGN_ELEMENT(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 _wrap_XML_RNGP_GRAMMAR_CONTENT(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 _wrap_XML_RNGP_GRAMMAR_EMPTY(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 _wrap_XML_RNGP_GRAMMAR_MISSING(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 _wrap_XML_RNGP_GRAMMAR_NO_START(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 _wrap_XML_RNGP_GROUP_ATTR_CONFLICT(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 _wrap_XML_RNGP_HREF_ERROR(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 _wrap_XML_RNGP_INCLUDE_EMPTY(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 _wrap_XML_RNGP_INCLUDE_FAILURE(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 _wrap_XML_RNGP_INCLUDE_RECURSE(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 _wrap_XML_RNGP_INTERLEAVE_ADD(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 _wrap_XML_RNGP_INTERLEAVE_CREATE_FAILED(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 _wrap_XML_RNGP_INTERLEAVE_EMPTY(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 _wrap_XML_RNGP_INTERLEAVE_NO_CONTENT(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 _wrap_XML_RNGP_INVALID_DEFINE_NAME(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 _wrap_XML_RNGP_INVALID_URI(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 _wrap_XML_RNGP_INVALID_VALUE(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 _wrap_XML_RNGP_MISSING_HREF(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 _wrap_XML_RNGP_NAME_MISSING(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 _wrap_XML_RNGP_NEED_COMBINE(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 _wrap_XML_RNGP_NOTALLOWED_NOT_EMPTY(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 _wrap_XML_RNGP_NSNAME_ATTR_ANCESTOR(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 _wrap_XML_RNGP_NSNAME_NO_NS(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 _wrap_XML_RNGP_PARAM_FORBIDDEN(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 _wrap_XML_RNGP_PARAM_NAME_MISSING(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 _wrap_XML_RNGP_PARENTREF_CREATE_FAILED(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 _wrap_XML_RNGP_PARENTREF_NAME_INVALID(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 _wrap_XML_RNGP_PARENTREF_NO_NAME(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 _wrap_XML_RNGP_PARENTREF_NO_PARENT(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 _wrap_XML_RNGP_PARENTREF_NOT_EMPTY(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 _wrap_XML_RNGP_PARSE_ERROR(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 _wrap_XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME(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 _wrap_XML_RNGP_PAT_ATTR_ATTR(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 _wrap_XML_RNGP_PAT_ATTR_ELEM(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 _wrap_XML_RNGP_PAT_DATA_EXCEPT_ATTR(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 _wrap_XML_RNGP_PAT_DATA_EXCEPT_ELEM(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 _wrap_XML_RNGP_PAT_DATA_EXCEPT_EMPTY(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 _wrap_XML_RNGP_PAT_DATA_EXCEPT_GROUP(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 _wrap_XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE(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 _wrap_XML_RNGP_PAT_DATA_EXCEPT_LIST(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 _wrap_XML_RNGP_PAT_DATA_EXCEPT_ONEMORE(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 _wrap_XML_RNGP_PAT_DATA_EXCEPT_REF(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 _wrap_XML_RNGP_PAT_DATA_EXCEPT_TEXT(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 _wrap_XML_RNGP_PAT_LIST_ATTR(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 _wrap_XML_RNGP_PAT_LIST_ELEM(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 _wrap_XML_RNGP_PAT_LIST_INTERLEAVE(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 _wrap_XML_RNGP_PAT_LIST_LIST(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 _wrap_XML_RNGP_PAT_LIST_REF(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 _wrap_XML_RNGP_PAT_LIST_TEXT(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 _wrap_XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME(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 _wrap_XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME(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 _wrap_XML_RNGP_PAT_ONEMORE_GROUP_ATTR(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 _wrap_XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR(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 _wrap_XML_RNGP_PAT_START_ATTR(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 _wrap_XML_RNGP_PAT_START_DATA(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 _wrap_XML_RNGP_PAT_START_EMPTY(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 _wrap_XML_RNGP_PAT_START_GROUP(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 _wrap_XML_RNGP_PAT_START_INTERLEAVE(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 _wrap_XML_RNGP_PAT_START_LIST(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 _wrap_XML_RNGP_PAT_START_ONEMORE(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 _wrap_XML_RNGP_PAT_START_TEXT(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 _wrap_XML_RNGP_PAT_START_VALUE(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 _wrap_XML_RNGP_PREFIX_UNDEFINED(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 _wrap_XML_RNGP_REF_CREATE_FAILED(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 _wrap_XML_RNGP_REF_CYCLE(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 _wrap_XML_RNGP_REF_NAME_INVALID(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 _wrap_XML_RNGP_REF_NO_DEF(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 _wrap_XML_RNGP_REF_NO_NAME(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 _wrap_XML_RNGP_REF_NOT_EMPTY(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 _wrap_XML_RNGP_START_CHOICE_AND_INTERLEAVE(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 _wrap_XML_RNGP_START_CONTENT(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 _wrap_XML_RNGP_START_EMPTY(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 _wrap_XML_RNGP_START_MISSING(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 _wrap_XML_RNGP_TEXT_EXPECTED(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 _wrap_XML_RNGP_TEXT_HAS_CHILD(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 _wrap_XML_RNGP_TYPE_MISSING(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 _wrap_XML_RNGP_TYPE_NOT_FOUND(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 _wrap_XML_RNGP_TYPE_VALUE(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 _wrap_XML_RNGP_UNKNOWN_ATTRIBUTE(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 _wrap_XML_RNGP_UNKNOWN_COMBINE(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 _wrap_XML_RNGP_UNKNOWN_CONSTRUCT(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 _wrap_XML_RNGP_UNKNOWN_TYPE_LIB(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 _wrap_XML_RNGP_URI_FRAGMENT(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 _wrap_XML_RNGP_URI_NOT_ABSOLUTE(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 _wrap_XML_RNGP_VALUE_EMPTY(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 _wrap_XML_RNGP_VALUE_NO_CONTENT(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 _wrap_XML_RNGP_XMLNS_NAME(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 _wrap_XML_RNGP_XML_NS(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 _wrap_XML_XPATH_EXPRESSION_OK(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 _wrap_XML_XPATH_NUMBER_ERROR(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 _wrap_XML_XPATH_UNFINISHED_LITERAL_ERROR(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 _wrap_XML_XPATH_START_LITERAL_ERROR(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 _wrap_XML_XPATH_VARIABLE_REF_ERROR(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 _wrap_XML_XPATH_UNDEF_VARIABLE_ERROR(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 _wrap_XML_XPATH_INVALID_PREDICATE_ERROR(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 _wrap_XML_XPATH_EXPR_ERROR(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 _wrap_XML_XPATH_UNCLOSED_ERROR(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 _wrap_XML_XPATH_UNKNOWN_FUNC_ERROR(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 _wrap_XML_XPATH_INVALID_OPERAND(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 _wrap_XML_XPATH_INVALID_TYPE(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 _wrap_XML_XPATH_INVALID_ARITY(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 _wrap_XML_XPATH_INVALID_CTXT_SIZE(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 _wrap_XML_XPATH_INVALID_CTXT_POSITION(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 _wrap_XML_XPATH_MEMORY_ERROR(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 _wrap_XML_XPTR_SYNTAX_ERROR(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 _wrap_XML_XPTR_RESOURCE_ERROR(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 _wrap_XML_XPTR_SUB_RESOURCE_ERROR(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 _wrap_XML_XPATH_UNDEF_PREFIX_ERROR(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 _wrap_XML_XPATH_ENCODING_ERROR(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 _wrap_XML_XPATH_INVALID_CHAR_ERROR(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 _wrap_XML_TREE_INVALID_HEX(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 _wrap_XML_TREE_INVALID_DEC(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 _wrap_XML_TREE_UNTERMINATED_ENTITY(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 _wrap_XML_TREE_NOT_UTF8(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 _wrap_XML_SAVE_NOT_UTF8(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 _wrap_XML_SAVE_CHAR_INVALID(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 _wrap_XML_SAVE_NO_DOCTYPE(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 _wrap_XML_SAVE_UNKNOWN_ENCODING(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 _wrap_XML_REGEXP_COMPILE_ERROR(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 _wrap_XML_IO_UNKNOWN(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 _wrap_XML_IO_EACCES(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 _wrap_XML_IO_EAGAIN(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 _wrap_XML_IO_EBADF(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 _wrap_XML_IO_EBADMSG(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 _wrap_XML_IO_EBUSY(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 _wrap_XML_IO_ECANCELED(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 _wrap_XML_IO_ECHILD(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 _wrap_XML_IO_EDEADLK(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 _wrap_XML_IO_EDOM(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 _wrap_XML_IO_EEXIST(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 _wrap_XML_IO_EFAULT(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 _wrap_XML_IO_EFBIG(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 _wrap_XML_IO_EINPROGRESS(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 _wrap_XML_IO_EINTR(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 _wrap_XML_IO_EINVAL(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 _wrap_XML_IO_EIO(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 _wrap_XML_IO_EISDIR(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 _wrap_XML_IO_EMFILE(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 _wrap_XML_IO_EMLINK(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 _wrap_XML_IO_EMSGSIZE(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 _wrap_XML_IO_ENAMETOOLONG(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 _wrap_XML_IO_ENFILE(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 _wrap_XML_IO_ENODEV(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 _wrap_XML_IO_ENOENT(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 _wrap_XML_IO_ENOEXEC(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 _wrap_XML_IO_ENOLCK(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 _wrap_XML_IO_ENOMEM(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 _wrap_XML_IO_ENOSPC(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 _wrap_XML_IO_ENOSYS(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 _wrap_XML_IO_ENOTDIR(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 _wrap_XML_IO_ENOTEMPTY(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 _wrap_XML_IO_ENOTSUP(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 _wrap_XML_IO_ENOTTY(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 _wrap_XML_IO_ENXIO(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 _wrap_XML_IO_EPERM(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 _wrap_XML_IO_EPIPE(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 _wrap_XML_IO_ERANGE(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 _wrap_XML_IO_EROFS(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 _wrap_XML_IO_ESPIPE(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 _wrap_XML_IO_ESRCH(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 _wrap_XML_IO_ETIMEDOUT(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 _wrap_XML_IO_EXDEV(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 _wrap_XML_IO_NETWORK_ATTEMPT(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 _wrap_XML_IO_ENCODER(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 _wrap_XML_IO_FLUSH(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 _wrap_XML_IO_WRITE(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 _wrap_XML_IO_NO_INPUT(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 _wrap_XML_IO_BUFFER_FULL(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 _wrap_XML_IO_LOAD_ERROR(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 _wrap_XML_IO_ENOTSOCK(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 _wrap_XML_IO_EISCONN(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 _wrap_XML_IO_ECONNREFUSED(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 _wrap_XML_IO_ENETUNREACH(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 _wrap_XML_IO_EADDRINUSE(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 _wrap_XML_IO_EALREADY(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 _wrap_XML_IO_EAFNOSUPPORT(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 _wrap_XML_XINCLUDE_RECURSION(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 _wrap_XML_XINCLUDE_PARSE_VALUE(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 _wrap_XML_XINCLUDE_ENTITY_DEF_MISMATCH(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 _wrap_XML_XINCLUDE_NO_HREF(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 _wrap_XML_XINCLUDE_NO_FALLBACK(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 _wrap_XML_XINCLUDE_HREF_URI(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 _wrap_XML_XINCLUDE_TEXT_FRAGMENT(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 _wrap_XML_XINCLUDE_TEXT_DOCUMENT(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 _wrap_XML_XINCLUDE_INVALID_CHAR(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 _wrap_XML_XINCLUDE_BUILD_FAILED(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 _wrap_XML_XINCLUDE_UNKNOWN_ENCODING(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 _wrap_XML_XINCLUDE_MULTIPLE_ROOT(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 _wrap_XML_XINCLUDE_XPTR_FAILED(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 _wrap_XML_XINCLUDE_XPTR_RESULT(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 _wrap_XML_XINCLUDE_INCLUDE_IN_INCLUDE(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 _wrap_XML_XINCLUDE_FALLBACKS_IN_INCLUDE(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 _wrap_XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE(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 _wrap_XML_XINCLUDE_DEPRECATED_NS(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 _wrap_XML_XINCLUDE_FRAGMENT_ID(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 _wrap_XML_CATALOG_MISSING_ATTR(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 _wrap_XML_CATALOG_ENTRY_BROKEN(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 _wrap_XML_CATALOG_PREFER_VALUE(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 _wrap_XML_CATALOG_NOT_CATALOG(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 _wrap_XML_CATALOG_RECURSION(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 _wrap_XML_SCHEMAP_PREFIX_UNDEFINED(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 _wrap_XML_SCHEMAP_ATTRFORMDEFAULT_VALUE(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 _wrap_XML_SCHEMAP_ATTRGRP_NONAME_NOREF(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 _wrap_XML_SCHEMAP_ATTR_NONAME_NOREF(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 _wrap_XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF(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 _wrap_XML_SCHEMAP_ELEMFORMDEFAULT_VALUE(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 _wrap_XML_SCHEMAP_ELEM_NONAME_NOREF(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 _wrap_XML_SCHEMAP_EXTENSION_NO_BASE(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 _wrap_XML_SCHEMAP_FACET_NO_VALUE(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 _wrap_XML_SCHEMAP_FAILED_BUILD_IMPORT(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 _wrap_XML_SCHEMAP_GROUP_NONAME_NOREF(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 _wrap_XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI(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 _wrap_XML_SCHEMAP_IMPORT_REDEFINE_NSNAME(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 _wrap_XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI(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 _wrap_XML_SCHEMAP_INVALID_BOOLEAN(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 _wrap_XML_SCHEMAP_INVALID_ENUM(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 _wrap_XML_SCHEMAP_INVALID_FACET(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 _wrap_XML_SCHEMAP_INVALID_FACET_VALUE(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 _wrap_XML_SCHEMAP_INVALID_MAXOCCURS(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 _wrap_XML_SCHEMAP_INVALID_MINOCCURS(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 _wrap_XML_SCHEMAP_INVALID_REF_AND_SUBTYPE(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 _wrap_XML_SCHEMAP_INVALID_WHITE_SPACE(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 _wrap_XML_SCHEMAP_NOATTR_NOREF(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 _wrap_XML_SCHEMAP_NOTATION_NO_NAME(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 _wrap_XML_SCHEMAP_NOTYPE_NOREF(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 _wrap_XML_SCHEMAP_REF_AND_SUBTYPE(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 _wrap_XML_SCHEMAP_RESTRICTION_NONAME_NOREF(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 _wrap_XML_SCHEMAP_SIMPLETYPE_NONAME(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 _wrap_XML_SCHEMAP_TYPE_AND_SUBTYPE(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 _wrap_XML_SCHEMAP_UNKNOWN_ALL_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_ATTR_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP(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 _wrap_XML_SCHEMAP_UNKNOWN_BASE_TYPE(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 _wrap_XML_SCHEMAP_UNKNOWN_CHOICE_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_ELEM_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_FACET_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_FACET_TYPE(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 _wrap_XML_SCHEMAP_UNKNOWN_GROUP_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_IMPORT_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_LIST_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_NOTATION_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_REF(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 _wrap_XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD(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 _wrap_XML_SCHEMAP_UNKNOWN_TYPE(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 _wrap_XML_SCHEMAP_UNKNOWN_UNION_CHILD(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 _wrap_XML_SCHEMAP_ELEM_DEFAULT_FIXED(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 _wrap_XML_SCHEMAP_REGEXP_INVALID(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 _wrap_XML_SCHEMAP_FAILED_LOAD(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 _wrap_XML_SCHEMAP_NOTHING_TO_PARSE(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 _wrap_XML_SCHEMAP_NOROOT(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 _wrap_XML_SCHEMAP_REDEFINED_GROUP(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 _wrap_XML_SCHEMAP_REDEFINED_TYPE(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 _wrap_XML_SCHEMAP_REDEFINED_ELEMENT(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 _wrap_XML_SCHEMAP_REDEFINED_ATTRGROUP(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 _wrap_XML_SCHEMAP_REDEFINED_ATTR(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 _wrap_XML_SCHEMAP_REDEFINED_NOTATION(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 _wrap_XML_SCHEMAP_FAILED_PARSE(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 _wrap_XML_SCHEMAP_UNKNOWN_PREFIX(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 _wrap_XML_SCHEMAP_DEF_AND_PREFIX(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 _wrap_XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD(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 _wrap_XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI(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 _wrap_XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI(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 _wrap_XML_SCHEMAP_NOT_SCHEMA(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 _wrap_XML_SCHEMAP_UNKNOWN_MEMBER_TYPE(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 _wrap_XML_SCHEMAP_INVALID_ATTR_USE(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 _wrap_XML_SCHEMAP_RECURSIVE(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 _wrap_XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE(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 _wrap_XML_SCHEMAP_INVALID_ATTR_COMBINATION(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 _wrap_XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION(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 _wrap_XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD(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 _wrap_XML_SCHEMAP_INVALID_ATTR_NAME(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 _wrap_XML_SCHEMAP_REF_AND_CONTENT(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 _wrap_XML_SCHEMAP_CT_PROPS_CORRECT_1(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 _wrap_XML_SCHEMAP_CT_PROPS_CORRECT_2(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 _wrap_XML_SCHEMAP_CT_PROPS_CORRECT_3(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 _wrap_XML_SCHEMAP_CT_PROPS_CORRECT_4(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 _wrap_XML_SCHEMAP_CT_PROPS_CORRECT_5(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 _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1(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 _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1(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 _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2(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 _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2(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 _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3(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 _wrap_XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER(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 _wrap_XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE(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 _wrap_XML_SCHEMAP_UNION_NOT_EXPRESSIBLE(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 _wrap_XML_SCHEMAP_SRC_IMPORT_3_1(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 _wrap_XML_SCHEMAP_SRC_IMPORT_3_2(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 _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1(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 _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2(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 _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3(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 _wrap_XML_SCHEMAP_COS_CT_EXTENDS_1_3(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 _wrap_XML_SCHEMAV_NOROOT(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 _wrap_XML_SCHEMAV_UNDECLAREDELEM(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 _wrap_XML_SCHEMAV_NOTTOPLEVEL(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 _wrap_XML_SCHEMAV_MISSING(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 _wrap_XML_SCHEMAV_WRONGELEM(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 _wrap_XML_SCHEMAV_NOTYPE(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 _wrap_XML_SCHEMAV_NOROLLBACK(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 _wrap_XML_SCHEMAV_ISABSTRACT(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 _wrap_XML_SCHEMAV_NOTEMPTY(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 _wrap_XML_SCHEMAV_ELEMCONT(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 _wrap_XML_SCHEMAV_HAVEDEFAULT(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 _wrap_XML_SCHEMAV_NOTNILLABLE(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 _wrap_XML_SCHEMAV_EXTRACONTENT(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 _wrap_XML_SCHEMAV_INVALIDATTR(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 _wrap_XML_SCHEMAV_INVALIDELEM(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 _wrap_XML_SCHEMAV_NOTDETERMINIST(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 _wrap_XML_SCHEMAV_CONSTRUCT(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 _wrap_XML_SCHEMAV_INTERNAL(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 _wrap_XML_SCHEMAV_NOTSIMPLE(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 _wrap_XML_SCHEMAV_ATTRUNKNOWN(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 _wrap_XML_SCHEMAV_ATTRINVALID(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 _wrap_XML_SCHEMAV_VALUE(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 _wrap_XML_SCHEMAV_FACET(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 _wrap_XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1(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 _wrap_XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2(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 _wrap_XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3(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 _wrap_XML_SCHEMAV_CVC_TYPE_3_1_1(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 _wrap_XML_SCHEMAV_CVC_TYPE_3_1_2(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 _wrap_XML_SCHEMAV_CVC_FACET_VALID(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 _wrap_XML_SCHEMAV_CVC_LENGTH_VALID(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 _wrap_XML_SCHEMAV_CVC_MINLENGTH_VALID(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 _wrap_XML_SCHEMAV_CVC_MAXLENGTH_VALID(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 _wrap_XML_SCHEMAV_CVC_MININCLUSIVE_VALID(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 _wrap_XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID(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 _wrap_XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID(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 _wrap_XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID(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 _wrap_XML_SCHEMAV_CVC_TOTALDIGITS_VALID(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 _wrap_XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID(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 _wrap_XML_SCHEMAV_CVC_PATTERN_VALID(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 _wrap_XML_SCHEMAV_CVC_ENUMERATION_VALID(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 _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1(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 _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2(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 _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3(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 _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4(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 _wrap_XML_SCHEMAV_CVC_ELT_1(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 _wrap_XML_SCHEMAV_CVC_ELT_2(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 _wrap_XML_SCHEMAV_CVC_ELT_3_1(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 _wrap_XML_SCHEMAV_CVC_ELT_3_2_1(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 _wrap_XML_SCHEMAV_CVC_ELT_3_2_2(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 _wrap_XML_SCHEMAV_CVC_ELT_4_1(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 _wrap_XML_SCHEMAV_CVC_ELT_4_2(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 _wrap_XML_SCHEMAV_CVC_ELT_4_3(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 _wrap_XML_SCHEMAV_CVC_ELT_5_1_1(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 _wrap_XML_SCHEMAV_CVC_ELT_5_1_2(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 _wrap_XML_SCHEMAV_CVC_ELT_5_2_1(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 _wrap_XML_SCHEMAV_CVC_ELT_5_2_2_1(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 _wrap_XML_SCHEMAV_CVC_ELT_5_2_2_2_1(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 _wrap_XML_SCHEMAV_CVC_ELT_5_2_2_2_2(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 _wrap_XML_SCHEMAV_CVC_ELT_6(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 _wrap_XML_SCHEMAV_CVC_ELT_7(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 _wrap_XML_SCHEMAV_CVC_ATTRIBUTE_1(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 _wrap_XML_SCHEMAV_CVC_ATTRIBUTE_2(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 _wrap_XML_SCHEMAV_CVC_ATTRIBUTE_3(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 _wrap_XML_SCHEMAV_CVC_ATTRIBUTE_4(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 _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1(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 _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1(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 _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2(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 _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_4(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 _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1(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 _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2(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 _wrap_XML_SCHEMAV_ELEMENT_CONTENT(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 _wrap_XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING(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 _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_1(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 _wrap_XML_SCHEMAV_CVC_AU(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 _wrap_XML_SCHEMAV_CVC_TYPE_1(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 _wrap_XML_SCHEMAV_CVC_TYPE_2(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 _wrap_XML_SCHEMAV_CVC_IDC(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 _wrap_XML_SCHEMAV_CVC_WILDCARD(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 _wrap_XML_SCHEMAV_MISC(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 _wrap_XML_XPTR_UNKNOWN_SCHEME(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 _wrap_XML_XPTR_CHILDSEQ_START(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 _wrap_XML_XPTR_EVAL_FAILED(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 _wrap_XML_XPTR_EXTRA_OBJECTS(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 _wrap_XML_C14N_CREATE_CTXT(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 _wrap_XML_C14N_REQUIRES_UTF8(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 _wrap_XML_C14N_CREATE_STACK(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 _wrap_XML_C14N_INVALID_NODE(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 _wrap_XML_C14N_UNKNOW_NODE(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 _wrap_XML_C14N_RELATIVE_NAMESPACE(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 _wrap_XML_FTP_PASV_ANSWER(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 _wrap_XML_FTP_EPSV_ANSWER(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 _wrap_XML_FTP_ACCNT(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 _wrap_XML_FTP_URL_SYNTAX(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 _wrap_XML_HTTP_URL_SYNTAX(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 _wrap_XML_HTTP_USE_IP(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 _wrap_XML_HTTP_UNKNOWN_HOST(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 _wrap_XML_SCHEMAP_SRC_SIMPLE_TYPE_1(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 _wrap_XML_SCHEMAP_SRC_SIMPLE_TYPE_2(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 _wrap_XML_SCHEMAP_SRC_SIMPLE_TYPE_3(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 _wrap_XML_SCHEMAP_SRC_SIMPLE_TYPE_4(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 _wrap_XML_SCHEMAP_SRC_RESOLVE(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 _wrap_XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE(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 _wrap_XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE(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 _wrap_XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES(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 _wrap_XML_SCHEMAP_ST_PROPS_CORRECT_1(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 _wrap_XML_SCHEMAP_ST_PROPS_CORRECT_2(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 _wrap_XML_SCHEMAP_ST_PROPS_CORRECT_3(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_1_1(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_1_2(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_2_1(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_3_1(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4(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 _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5(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 _wrap_XML_SCHEMAP_COS_ST_DERIVED_OK_2_1(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 _wrap_XML_SCHEMAP_COS_ST_DERIVED_OK_2_2(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 _wrap_XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED(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 _wrap_XML_SCHEMAP_S4S_ELEM_MISSING(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 _wrap_XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED(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 _wrap_XML_SCHEMAP_S4S_ATTR_MISSING(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 _wrap_XML_SCHEMAP_S4S_ATTR_INVALID_VALUE(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 _wrap_XML_SCHEMAP_SRC_ELEMENT_1(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 _wrap_XML_SCHEMAP_SRC_ELEMENT_2_1(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 _wrap_XML_SCHEMAP_SRC_ELEMENT_2_2(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 _wrap_XML_SCHEMAP_SRC_ELEMENT_3(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 _wrap_XML_SCHEMAP_P_PROPS_CORRECT_1(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 _wrap_XML_SCHEMAP_P_PROPS_CORRECT_2_1(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 _wrap_XML_SCHEMAP_P_PROPS_CORRECT_2_2(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 _wrap_XML_SCHEMAP_E_PROPS_CORRECT_2(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 _wrap_XML_SCHEMAP_E_PROPS_CORRECT_3(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 _wrap_XML_SCHEMAP_E_PROPS_CORRECT_4(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 _wrap_XML_SCHEMAP_E_PROPS_CORRECT_5(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 _wrap_XML_SCHEMAP_E_PROPS_CORRECT_6(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 _wrap_XML_SCHEMAP_SRC_INCLUDE(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 _wrap_XML_SCHEMAP_SRC_ATTRIBUTE_1(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 _wrap_XML_SCHEMAP_SRC_ATTRIBUTE_2(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 _wrap_XML_SCHEMAP_SRC_ATTRIBUTE_3_1(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 _wrap_XML_SCHEMAP_SRC_ATTRIBUTE_3_2(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 _wrap_XML_SCHEMAP_SRC_ATTRIBUTE_4(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 _wrap_XML_SCHEMAP_NO_XMLNS(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 _wrap_XML_SCHEMAP_NO_XSI(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 _wrap_XML_SCHEMAP_COS_VALID_DEFAULT_1(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 _wrap_XML_SCHEMAP_COS_VALID_DEFAULT_2_1(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 _wrap_XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1(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 _wrap_XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2(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 _wrap_XML_SCHEMAP_CVC_SIMPLE_TYPE(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 _wrap_XML_SCHEMAP_COS_CT_EXTENDS_1_1(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 _wrap_XML_SCHEMAP_SRC_IMPORT_1_1(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 _wrap_XML_SCHEMAP_SRC_IMPORT_1_2(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 _wrap_XML_SCHEMAP_SRC_IMPORT_2(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 _wrap_XML_SCHEMAP_SRC_IMPORT_2_1(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 _wrap_XML_SCHEMAP_SRC_IMPORT_2_2(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 _wrap_XML_SCHEMAP_INTERNAL(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 _wrap_XML_SCHEMAP_NOT_DETERMINISTIC(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 _wrap_XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1(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 _wrap_XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2(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 _wrap_XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3(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 _wrap_XML_SCHEMAP_MG_PROPS_CORRECT_1(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 _wrap_XML_SCHEMAP_MG_PROPS_CORRECT_2(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 _wrap_XML_SCHEMAP_SRC_CT_1(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 _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3(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 _wrap_XML_SCHEMAP_AU_PROPS_CORRECT_2(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 _wrap_XML_SCHEMAP_A_PROPS_CORRECT_2(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 _wrap_XML_SCHEMAP_C_PROPS_CORRECT(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 _wrap_XML_SCHEMAP_SRC_REDEFINE(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 _wrap_XML_SCHEMAP_SRC_IMPORT(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 _wrap_XML_SCHEMAP_WARN_SKIP_SCHEMA(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 _wrap_XML_SCHEMAP_WARN_UNLOCATED_SCHEMA(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 _wrap_XML_SCHEMAP_WARN_ATTR_REDECL_PROH(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 _wrap_XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH(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 _wrap_XML_SCHEMAP_AG_PROPS_CORRECT(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 _wrap_XML_SCHEMAP_COS_CT_EXTENDS_1_2(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 _wrap_XML_SCHEMAP_AU_PROPS_CORRECT(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 _wrap_XML_SCHEMAP_A_PROPS_CORRECT_3(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 _wrap_XML_SCHEMAP_COS_ALL_LIMITED(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 _wrap_XML_SCHEMATRONV_ASSERT(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 _wrap_XML_SCHEMATRONV_REPORT(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 _wrap_XML_MODULE_OPEN(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 _wrap_XML_MODULE_CLOSE(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 _wrap_XML_CHECK_FOUND_ELEMENT(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 _wrap_XML_CHECK_FOUND_ATTRIBUTE(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 _wrap_XML_CHECK_FOUND_TEXT(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 _wrap_XML_CHECK_FOUND_CDATA(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 _wrap_XML_CHECK_FOUND_ENTITYREF(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 _wrap_XML_CHECK_FOUND_ENTITY(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 _wrap_XML_CHECK_FOUND_PI(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 _wrap_XML_CHECK_FOUND_COMMENT(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 _wrap_XML_CHECK_FOUND_DOCTYPE(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 _wrap_XML_CHECK_FOUND_FRAGMENT(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 _wrap_XML_CHECK_FOUND_NOTATION(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 _wrap_XML_CHECK_UNKNOWN_NODE(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 _wrap_XML_CHECK_ENTITY_TYPE(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 _wrap_XML_CHECK_NO_PARENT(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 _wrap_XML_CHECK_NO_DOC(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 _wrap_XML_CHECK_NO_NAME(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 _wrap_XML_CHECK_NO_ELEM(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 _wrap_XML_CHECK_WRONG_DOC(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 _wrap_XML_CHECK_NO_PREV(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 _wrap_XML_CHECK_WRONG_PREV(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 _wrap_XML_CHECK_NO_NEXT(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 _wrap_XML_CHECK_WRONG_NEXT(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 _wrap_XML_CHECK_NOT_DTD(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 _wrap_XML_CHECK_NOT_ATTR(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 _wrap_XML_CHECK_NOT_ATTR_DECL(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 _wrap_XML_CHECK_NOT_ELEM_DECL(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 _wrap_XML_CHECK_NOT_ENTITY_DECL(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 _wrap_XML_CHECK_NOT_NS_DECL(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 _wrap_XML_CHECK_NO_HREF(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 _wrap_XML_CHECK_WRONG_PARENT(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 _wrap_XML_CHECK_NS_SCOPE(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 _wrap_XML_CHECK_NS_ANCESTOR(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 _wrap_XML_CHECK_NOT_UTF8(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 _wrap_XML_CHECK_NO_DICT(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 _wrap_XML_CHECK_NOT_NCNAME(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 _wrap_XML_CHECK_OUTSIDE_DICT(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 _wrap_XML_CHECK_WRONG_NAME(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 _wrap_XML_CHECK_NAME_NOT_NULL(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 _wrap_XML_I18N_NO_NAME(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 _wrap_XML_I18N_NO_HANDLER(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 _wrap_XML_I18N_EXCESS_HANDLER(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 _wrap_XML_I18N_CONV_FAILED(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 _wrap_XML_I18N_NO_OUTPUT(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 _wrap_XML_BUF_OVERFLOW(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_xmlSetGenericErrorFunc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlGenericErrorFunc arg2 = (xmlGenericErrorFunc) 0 ;
  
  if(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_initGenericErrorDefaultFunc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlGenericErrorFunc *arg1 = (xmlGenericErrorFunc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if(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) 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__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_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) 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) 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) 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) 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;
  xmlParserInputPtr arg1 = (xmlParserInputPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if(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 '" "xmlParserInputPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserInputPtr >(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;
  xmlParserInputPtr arg1 = (xmlParserInputPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if(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 '" "xmlParserInputPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserInputPtr >(argp1);
  xmlParserPrintFileContext(arg1);
  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;
  xmlErrorPtr result;
  
  if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetLastError.");
  
  result = (xmlErrorPtr)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) 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 ;
  xmlErrorPtr result;
  
  if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCtxtGetLastError.");
  
  arg1 = getSwigCObjectPtr(args[0]);
  result = (xmlErrorPtr)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) 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) 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;
  xmlErrorPtr arg1 = (xmlErrorPtr) 0 ;
  xmlErrorPtr arg2 = (xmlErrorPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if(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 '" "xmlErrorPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlErrorPtr >(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(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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) (xmlListPtr)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlListPtr result;
  
  if(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 const""'"); 
  }
  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) (xmlListPtr)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if(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 const""'"); 
  }
  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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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 ;
  xmlRegexpPtr result;
  
  if(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 = (xmlRegexpPtr)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) 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_finishDtd_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_finishDtd_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_finishDtd_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->finishDtd = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlValidCtxt_finishDtd_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_finishDtd_get" "', argument " "1"" of type '" "_xmlValidCtxt *""'"); 
  }
  arg1 = reinterpret_cast< _xmlValidCtxt * >(argp1);
  result = (unsigned int) ((arg1)->finishDtd);
  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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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_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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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 _wrap_XML_INTERNAL_GENERAL_ENTITY(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 _wrap_XML_EXTERNAL_GENERAL_PARSED_ENTITY(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 _wrap_XML_EXTERNAL_GENERAL_UNPARSED_ENTITY(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 _wrap_XML_INTERNAL_PARAMETER_ENTITY(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 _wrap_XML_EXTERNAL_PARAMETER_ENTITY(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 _wrap_XML_INTERNAL_PREDEFINED_ENTITY(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__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) 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_xmlInitializePredefinedEntities(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlInitializePredefinedEntities.");
  
  xmlInitializePredefinedEntities();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  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) 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_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) 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) 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) 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) 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) 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) 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_xmlEncodeEntities(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlEncodeEntities.");
  
  res1 = SWIG_ConvertPtr(args[0], &arg10, SWIGTYPE_p__xmlDoc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method 'xmlEncodeEntities', 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 '" "xmlEncodeEntities" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }
  result = (xmlChar *)xmlEncodeEntities(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_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) 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) 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) 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) 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) 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) 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) 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 _wrap_xmlCleanupPredefinedEntities(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlCleanupPredefinedEntities.");
  
  xmlCleanupPredefinedEntities();
  jsresult = SWIGV8_UNDEFINED();
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_XML_DEFAULT_VERSION(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_standalone_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_standalone_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_standalone_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->standalone = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlParserInput_standalone_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_standalone_get" "', argument " "1"" of type '" "_xmlParserInput *""'"); 
  }
  arg1 = reinterpret_cast< _xmlParserInput * >(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__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 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) 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) 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) 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 _wrap_XML_PARSER_EOF(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 _wrap_XML_PARSER_START(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 _wrap_XML_PARSER_MISC(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 _wrap_XML_PARSER_PI(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 _wrap_XML_PARSER_DTD(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 _wrap_XML_PARSER_PROLOG(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 _wrap_XML_PARSER_COMMENT(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 _wrap_XML_PARSER_START_TAG(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 _wrap_XML_PARSER_CONTENT(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 _wrap_XML_PARSER_CDATA_SECTION(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 _wrap_XML_PARSER_END_TAG(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 _wrap_XML_PARSER_ENTITY_DECL(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 _wrap_XML_PARSER_ENTITY_VALUE(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 _wrap_XML_PARSER_ATTRIBUTE_VALUE(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 _wrap_XML_PARSER_SYSTEM_LITERAL(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 _wrap_XML_PARSER_EPILOG(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 _wrap_XML_PARSER_IGNORE(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 _wrap_XML_PARSER_PUBLIC_LITERAL(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 _wrap_XML_DETECT_IDS(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 _wrap_XML_COMPLETE_ATTRS(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 _wrap_XML_SKIP_IDS(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 _wrap_XML_PARSE_UNKNOWN(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 _wrap_XML_PARSE_DOM(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 _wrap_XML_PARSE_SAX(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 _wrap_XML_PARSE_PUSH_DOM(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 _wrap_XML_PARSE_PUSH_SAX(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 _wrap_XML_PARSE_READER(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 ;
  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_attallocs_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_attallocs_set" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< 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 ;
  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 = (int *) ((arg1)->attallocs);
  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_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 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) 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) 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 _wrap_XML_SAX2_MAGIC(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__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__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) 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) 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_XML_CHAR_ENCODING_ERROR(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 _wrap_XML_CHAR_ENCODING_NONE(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 _wrap_XML_CHAR_ENCODING_UTF8(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 _wrap_XML_CHAR_ENCODING_UTF16LE(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 _wrap_XML_CHAR_ENCODING_UTF16BE(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 _wrap_XML_CHAR_ENCODING_UCS4LE(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 _wrap_XML_CHAR_ENCODING_UCS4BE(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 _wrap_XML_CHAR_ENCODING_EBCDIC(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 _wrap_XML_CHAR_ENCODING_UCS4_2143(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 _wrap_XML_CHAR_ENCODING_UCS4_3412(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 _wrap_XML_CHAR_ENCODING_UCS2(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 _wrap_XML_CHAR_ENCODING_8859_1(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 _wrap_XML_CHAR_ENCODING_8859_2(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 _wrap_XML_CHAR_ENCODING_8859_3(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 _wrap_XML_CHAR_ENCODING_8859_4(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 _wrap_XML_CHAR_ENCODING_8859_5(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 _wrap_XML_CHAR_ENCODING_8859_6(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 _wrap_XML_CHAR_ENCODING_8859_7(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 _wrap_XML_CHAR_ENCODING_8859_8(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 _wrap_XML_CHAR_ENCODING_8859_9(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 _wrap_XML_CHAR_ENCODING_2022_JP(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 _wrap_XML_CHAR_ENCODING_SHIFT_JIS(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 _wrap_XML_CHAR_ENCODING_EUC_JP(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 _wrap_XML_CHAR_ENCODING_ASCII(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 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) 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) 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) 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) 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_xmlGetCharEncodingHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlCharEncoding arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  xmlCharEncodingHandlerPtr result;
  
  if(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) 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) 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) 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) 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) 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) 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) 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) 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) 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 ;
  xmlBufferPtr arg2 = (xmlBufferPtr) 0 ;
  xmlBufferPtr arg3 = (xmlBufferPtr) 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) 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 '" "xmlBufferPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlBufferPtr >(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 '" "xmlBufferPtr""'"); 
  }
  arg3 = reinterpret_cast< xmlBufferPtr >(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 ;
  xmlBufferPtr arg2 = (xmlBufferPtr) 0 ;
  xmlBufferPtr arg3 = (xmlBufferPtr) 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) 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 '" "xmlBufferPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlBufferPtr >(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 '" "xmlBufferPtr""'"); 
  }
  arg3 = reinterpret_cast< xmlBufferPtr >(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 ;
  xmlBufferPtr arg2 = (xmlBufferPtr) 0 ;
  xmlBufferPtr arg3 = (xmlBufferPtr) 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) 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 '" "xmlBufferPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlBufferPtr >(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 '" "xmlBufferPtr""'"); 
  }
  arg3 = reinterpret_cast< xmlBufferPtr >(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) 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) 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) 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 SwigV8ReturnValue _wrap_XLINK_TYPE_NONE(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 _wrap_XLINK_TYPE_SIMPLE(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 _wrap_XLINK_TYPE_EXTENDED(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 _wrap_XLINK_TYPE_EXTENDED_SET(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 _wrap_XLINK_SHOW_NONE(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 _wrap_XLINK_SHOW_NEW(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 _wrap_XLINK_SHOW_EMBED(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 _wrap_XLINK_SHOW_REPLACE(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 _wrap_XLINK_ACTUATE_NONE(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 _wrap_XLINK_ACTUATE_AUTO(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 _wrap_XLINK_ACTUATE_ONREQUEST(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) 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) 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) 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) 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) 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) 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 _wrap_xmlSAX2GetPublicId(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *result = 0 ;
  
  if(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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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_xmlSAX2InitDocbDefaultSAXHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandler *arg1 = (xmlSAXHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSAX2InitDocbDefaultSAXHandler.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSAX2InitDocbDefaultSAXHandler" "', argument " "1"" of type '" "xmlSAXHandler *""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandler * >(argp1);
  xmlSAX2InitDocbDefaultSAXHandler(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_docbDefaultSAXHandlerInit(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_docbDefaultSAXHandlerInit.");
  
  docbDefaultSAXHandlerInit();
  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) 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_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) 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) 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) 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) 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) 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) 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_xmlMemUsed(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  if(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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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_xmlInitGlobals(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if(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) 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_xmlParserInputBufferCreateFilenameDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserInputBufferCreateFilenameFunc arg1 = (xmlParserInputBufferCreateFilenameFunc) 0 ;
  xmlParserInputBufferCreateFilenameFunc result;
  
  if(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) 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_xmlNewMutex(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlMutexPtr result;
  
  if(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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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 _wrap_xmlGetGlobalState(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlGlobalStatePtr result;
  
  if(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_xmlInitializeGlobalState(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlGlobalStatePtr arg1 = (xmlGlobalStatePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if(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_xmlThrDefSetGenericErrorFunc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlGenericErrorFunc arg2 = (xmlGenericErrorFunc) 0 ;
  
  if(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_xmlThrDefSetStructuredErrorFunc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlStructuredErrorFunc arg2 = (xmlStructuredErrorFunc) 0 ;
  
  if(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__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_xmlRegisterNodeDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRegisterNodeFunc arg1 = (xmlRegisterNodeFunc) 0 ;
  xmlRegisterNodeFunc result;
  
  if(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_xmlThrDefRegisterNodeDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRegisterNodeFunc arg1 = (xmlRegisterNodeFunc) 0 ;
  xmlRegisterNodeFunc result;
  
  if(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_xmlDeregisterNodeDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDeregisterNodeFunc arg1 = (xmlDeregisterNodeFunc) 0 ;
  xmlDeregisterNodeFunc result;
  
  if(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_xmlThrDefDeregisterNodeDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDeregisterNodeFunc arg1 = (xmlDeregisterNodeFunc) 0 ;
  xmlDeregisterNodeFunc result;
  
  if(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_xmlThrDefOutputBufferCreateFilenameDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferCreateFilenameFunc arg1 = (xmlOutputBufferCreateFilenameFunc) 0 ;
  xmlOutputBufferCreateFilenameFunc result;
  
  if(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) 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 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___docbDefaultSAXHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerV1 *result = 0 ;
  
  if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap___docbDefaultSAXHandler.");
  
  result = (xmlSAXHandlerV1 *)__docbDefaultSAXHandler();
  jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static void _wrap_docbDefaultSAXHandler_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlSAXHandlerV1 *arg1 = (xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(value, &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "docbDefaultSAXHandler_set" "', argument " "1"" of type '" "xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandlerV1 * >(argp1);
  docbDefaultSAXHandler = *arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_docbDefaultSAXHandler_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerV1 *result = 0 ;
  
  result = (xmlSAXHandlerV1 *)&docbDefaultSAXHandler;
  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) 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 void _wrap_htmlDefaultSAXHandler_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlSAXHandlerV1 *arg1 = (xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(value, &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "htmlDefaultSAXHandler_set" "', argument " "1"" of type '" "xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandlerV1 * >(argp1);
  htmlDefaultSAXHandler = *arg1;
  
  
  goto fail;
fail:
  return;
}


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___xmlLastError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlError *result = 0 ;
  
  if(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 void _wrap_xmlLastError_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlError *arg1 = (xmlError *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(value, &argp1,SWIGTYPE_p__xmlError, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlLastError_set" "', argument " "1"" of type '" "xmlError *""'"); 
  }
  arg1 = reinterpret_cast< xmlError * >(argp1);
  xmlLastError = *arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlLastError_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlError *result = 0 ;
  
  result = (xmlError *)&xmlLastError;
  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 SwigV8ReturnValue _wrap___oldXMLWDcompatibility(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if(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 void _wrap_oldXMLWDcompatibility_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 '" "oldXMLWDcompatibility_set" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  oldXMLWDcompatibility = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_oldXMLWDcompatibility_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  result = (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___xmlBufferAllocScheme(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferAllocationScheme *result = 0 ;
  
  if(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 void _wrap_xmlBufferAllocScheme_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlBufferAllocationScheme arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  
  ecode1 = SWIG_AsVal_int(value, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlBufferAllocScheme_set" "', argument " "1"" of type '" "xmlBufferAllocationScheme""'");
  } 
  arg1 = static_cast< xmlBufferAllocationScheme >(val1);
  xmlBufferAllocScheme = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlBufferAllocScheme_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferAllocationScheme result;
  
  result = (xmlBufferAllocationScheme)xmlBufferAllocScheme;
  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_xmlThrDefBufferAllocScheme(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlBufferAllocationScheme arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  xmlBufferAllocationScheme result;
  
  if(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___xmlDefaultBufferSize(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if(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 void _wrap_xmlDefaultBufferSize_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 '" "xmlDefaultBufferSize_set" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  xmlDefaultBufferSize = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlDefaultBufferSize_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  result = (int)xmlDefaultBufferSize;
  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_xmlThrDefDefaultBufferSize(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if(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___xmlDefaultSAXHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerV1 *result = 0 ;
  
  if(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 void _wrap_xmlDefaultSAXHandler_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlSAXHandlerV1 *arg1 = (xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(value, &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDefaultSAXHandler_set" "', argument " "1"" of type '" "xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandlerV1 * >(argp1);
  xmlDefaultSAXHandler = *arg1;
  
  
  goto fail;
fail:
  return;
}


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___xmlDefaultSAXLocator(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXLocator *result = 0 ;
  
  if(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 void _wrap_xmlDefaultSAXLocator_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlSAXLocator *arg1 = (xmlSAXLocator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  res1 = SWIG_ConvertPtr(value, &argp1,SWIGTYPE_p__xmlSAXLocator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDefaultSAXLocator_set" "', argument " "1"" of type '" "xmlSAXLocator *""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXLocator * >(argp1);
  xmlDefaultSAXLocator = *arg1;
  
  
  goto fail;
fail:
  return;
}


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___xmlDoValidityCheckingDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if(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 void _wrap_xmlDoValidityCheckingDefaultValue_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 '" "xmlDoValidityCheckingDefaultValue_set" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  xmlDoValidityCheckingDefaultValue = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlDoValidityCheckingDefaultValue_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  result = (int)xmlDoValidityCheckingDefaultValue;
  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_xmlThrDefDoValidityCheckingDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if(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___xmlGenericError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlGenericErrorFunc *result = 0 ;
  
  if(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 void _wrap_xmlGenericError_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlGenericErrorFunc arg1 = (xmlGenericErrorFunc) 0 ;
  
  {
    int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg1), SWIGTYPE_p_f_p_void_p_q_const__char_v_______void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlGenericError_set" "', argument " "1"" of type '" "xmlGenericErrorFunc""'"); 
    }
  }
  xmlGenericError = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlGenericError_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlGenericErrorFunc result;
  
  result = (xmlGenericErrorFunc)xmlGenericError;
  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 SwigV8ReturnValue _wrap___xmlStructuredError(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlStructuredErrorFunc *result = 0 ;
  
  if(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__xmlError__void, 0 |  0 );
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


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


static SwigV8ReturnValue _wrap_xmlStructuredError_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlStructuredErrorFunc result;
  
  result = (xmlStructuredErrorFunc)xmlStructuredError;
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p__xmlError__void);
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap___xmlGenericErrorContext(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void **result = 0 ;
  
  if(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 void _wrap_xmlGenericErrorContext_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  void *arg1 = (void *) 0 ;
  
  arg1 = getSwigCObjectPtr(value);
  xmlGenericErrorContext = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlGenericErrorContext_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *result = 0 ;
  
  result = (void *)xmlGenericErrorContext;
  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___xmlStructuredErrorContext(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void **result = 0 ;
  
  if(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 void _wrap_xmlStructuredErrorContext_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  void *arg1 = (void *) 0 ;
  
  arg1 = getSwigCObjectPtr(value);
  xmlStructuredErrorContext = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlStructuredErrorContext_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *result = 0 ;
  
  result = (void *)xmlStructuredErrorContext;
  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___xmlGetWarningsDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if(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 void _wrap_xmlGetWarningsDefaultValue_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 '" "xmlGetWarningsDefaultValue_set" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  xmlGetWarningsDefaultValue = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlGetWarningsDefaultValue_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  result = (int)xmlGetWarningsDefaultValue;
  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_xmlThrDefGetWarningsDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if(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___xmlIndentTreeOutput(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if(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 void _wrap_xmlIndentTreeOutput_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 '" "xmlIndentTreeOutput_set" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  xmlIndentTreeOutput = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlIndentTreeOutput_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  result = (int)xmlIndentTreeOutput;
  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_xmlThrDefIndentTreeOutput(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if(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___xmlTreeIndentString(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char **result = 0 ;
  char *temp ;
  
  if(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 void _wrap_xmlTreeIndentString_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  
  if (value->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(value, &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlTreeIndentString_set" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }
  if (arg1) {
    size_t size = strlen(arg1) + 1;
    xmlTreeIndentString = (char const *)reinterpret_cast< char* >(memcpy(new char[size], arg1, sizeof(char)*(size)));
  } else {
    xmlTreeIndentString = 0;
  }
  // free(arg1);
  
  goto fail;
fail:
  return;
}


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


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) 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___xmlKeepBlanksDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if(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 void _wrap_xmlKeepBlanksDefaultValue_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 '" "xmlKeepBlanksDefaultValue_set" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  xmlKeepBlanksDefaultValue = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlKeepBlanksDefaultValue_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  result = (int)xmlKeepBlanksDefaultValue;
  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_xmlThrDefKeepBlanksDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if(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___xmlLineNumbersDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if(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 void _wrap_xmlLineNumbersDefaultValue_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 '" "xmlLineNumbersDefaultValue_set" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  xmlLineNumbersDefaultValue = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlLineNumbersDefaultValue_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  result = (int)xmlLineNumbersDefaultValue;
  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_xmlThrDefLineNumbersDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if(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___xmlLoadExtDtdDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if(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 void _wrap_xmlLoadExtDtdDefaultValue_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 '" "xmlLoadExtDtdDefaultValue_set" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  xmlLoadExtDtdDefaultValue = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlLoadExtDtdDefaultValue_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  result = (int)xmlLoadExtDtdDefaultValue;
  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_xmlThrDefLoadExtDtdDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if(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___xmlParserDebugEntities(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if(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 void _wrap_xmlParserDebugEntities_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 '" "xmlParserDebugEntities_set" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  xmlParserDebugEntities = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlParserDebugEntities_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  result = (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_xmlThrDefParserDebugEntities(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if(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___xmlParserVersion(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char **result = 0 ;
  char *temp ;
  
  if(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 void _wrap_xmlParserVersion_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  size_t size1 = 0 ;
  int alloc1 = 0 ;
  
  if (value->IsNull()) {
    arg1 = NULL;
  } else if (node::Buffer::HasInstance(value)) {
    arg1 = node::Buffer::Data(Nan::To<v8::Object>(value).ToLocalChecked());
    // printf("data: %s - %i\n", arg1, strlen(arg1));
  } else {
    res1 = SWIG_AsCharPtrAndSize(value, &buf1, &size1, &alloc1);
    
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserVersion_set" "', argument " "1"" of type '" "char const *""'");
    }
    
    arg1 = reinterpret_cast< char * >(buf1);
  }
  if (arg1) {
    size_t size = strlen(arg1) + 1;
    xmlParserVersion = (char const *)reinterpret_cast< char* >(memcpy(new char[size], arg1, sizeof(char)*(size)));
  } else {
    xmlParserVersion = 0;
  }
  // free(arg1);
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlParserVersion_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  char *result = 0 ;
  
  result = (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___xmlPedanticParserDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if(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 void _wrap_xmlPedanticParserDefaultValue_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 '" "xmlPedanticParserDefaultValue_set" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  xmlPedanticParserDefaultValue = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlPedanticParserDefaultValue_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  result = (int)xmlPedanticParserDefaultValue;
  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_xmlThrDefPedanticParserDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if(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___xmlSaveNoEmptyTags(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if(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 void _wrap_xmlSaveNoEmptyTags_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 '" "xmlSaveNoEmptyTags_set" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  xmlSaveNoEmptyTags = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlSaveNoEmptyTags_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  result = (int)xmlSaveNoEmptyTags;
  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_xmlThrDefSaveNoEmptyTags(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if(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___xmlSubstituteEntitiesDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *result = 0 ;
  
  if(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 void _wrap_xmlSubstituteEntitiesDefaultValue_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 '" "xmlSubstituteEntitiesDefaultValue_set" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  xmlSubstituteEntitiesDefaultValue = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlSubstituteEntitiesDefaultValue_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int result;
  
  result = (int)xmlSubstituteEntitiesDefaultValue;
  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_xmlThrDefSubstituteEntitiesDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if(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___xmlRegisterNodeDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRegisterNodeFunc *result = 0 ;
  
  if(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 void _wrap_xmlRegisterNodeDefaultValue_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlRegisterNodeFunc arg1 = (xmlRegisterNodeFunc) 0 ;
  
  {
    int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg1), SWIGTYPE_p_f_p__xmlNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlRegisterNodeDefaultValue_set" "', argument " "1"" of type '" "xmlRegisterNodeFunc""'"); 
    }
  }
  xmlRegisterNodeDefaultValue = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlRegisterNodeDefaultValue_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlRegisterNodeFunc result;
  
  result = (xmlRegisterNodeFunc)xmlRegisterNodeDefaultValue;
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p__xmlNode__void);
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap___xmlDeregisterNodeDefaultValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDeregisterNodeFunc *result = 0 ;
  
  if(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 void _wrap_xmlDeregisterNodeDefaultValue_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlDeregisterNodeFunc arg1 = (xmlDeregisterNodeFunc) 0 ;
  
  {
    int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg1), SWIGTYPE_p_f_p__xmlNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlDeregisterNodeDefaultValue_set" "', argument " "1"" of type '" "xmlDeregisterNodeFunc""'"); 
    }
  }
  xmlDeregisterNodeDefaultValue = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlDeregisterNodeDefaultValue_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlDeregisterNodeFunc result;
  
  result = (xmlDeregisterNodeFunc)xmlDeregisterNodeDefaultValue;
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p__xmlNode__void);
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap___xmlParserInputBufferCreateFilenameValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserInputBufferCreateFilenameFunc *result = 0 ;
  
  if(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 void _wrap_xmlParserInputBufferCreateFilenameValue_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlParserInputBufferCreateFilenameFunc arg1 = (xmlParserInputBufferCreateFilenameFunc) 0 ;
  
  {
    int res = SWIG_ConvertFunctionPtr(value, (void**)(&arg1), SWIGTYPE_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlParserInputBufferCreateFilenameValue_set" "', argument " "1"" of type '" "xmlParserInputBufferCreateFilenameFunc""'"); 
    }
  }
  xmlParserInputBufferCreateFilenameValue = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlParserInputBufferCreateFilenameValue_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserInputBufferCreateFilenameFunc result;
  
  result = (xmlParserInputBufferCreateFilenameFunc)xmlParserInputBufferCreateFilenameValue;
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_xmlCharEncoding__p__xmlParserInputBuffer);
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


static SwigV8ReturnValue _wrap___xmlOutputBufferCreateFilenameValue(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferCreateFilenameFunc *result = 0 ;
  
  if(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 void _wrap_xmlOutputBufferCreateFilenameValue_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  xmlOutputBufferCreateFilenameFunc arg1 = (xmlOutputBufferCreateFilenameFunc) 0 ;
  
  {
    int res = SWIG_ConvertFunctionPtr(value, (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 '" "xmlOutputBufferCreateFilenameValue_set" "', argument " "1"" of type '" "xmlOutputBufferCreateFilenameFunc""'"); 
    }
  }
  xmlOutputBufferCreateFilenameValue = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlOutputBufferCreateFilenameValue_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlOutputBufferCreateFilenameFunc result;
  
  result = (xmlOutputBufferCreateFilenameFunc)xmlOutputBufferCreateFilenameValue;
  jsresult = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_q_const__char_xmlCharEncodingHandlerPtr_int__p__xmlOutputBuffer);
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


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) 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) 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_xmlCleanupInputCallbacks(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if(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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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_xmlInitParser(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if(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) 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_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) 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) 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) 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) 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) 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) 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_xmlKeepBlanksDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if(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_xmlStopParser(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if(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) 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_xmlLineNumbersDefault(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  
  if(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_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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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_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) 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) 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) 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) 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) 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_xmlGetFeaturesList(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  int *arg1 = (int *) 0 ;
  char **arg2 = (char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetFeaturesList.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlGetFeaturesList" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlGetFeaturesList" "', argument " "2"" of type '" "char const **""'"); 
  }
  arg2 = reinterpret_cast< char ** >(argp2);
  result = (int)xmlGetFeaturesList(arg1,(char const **)arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlGetFeature(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 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 ;
  int result;
  
  if(args.Length() != 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlGetFeature.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlGetFeature" "', 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 '" "xmlGetFeature" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }
  arg3 = getSwigCObjectPtr(args[2]);
  result = (int)xmlGetFeature(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_xmlSetFeature(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 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 ;
  int result;
  
  if(args.Length() != 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSetFeature.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlSetFeature" "', 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 '" "xmlSetFeature" "', argument " "2"" of type '" "char const *""'");
    }
    
    arg2 = reinterpret_cast< char * >(buf2);
  }
  arg3 = getSwigCObjectPtr(args[2]);
  result = (int)xmlSetFeature(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_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) 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) 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) 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) 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) (xmlParserCtxtPtr)0 ;
  xmlNodePtr arg2 = (xmlNodePtr) (xmlNodePtr)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlParserNodeInfo *result = 0 ;
  
  if(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 const""'"); 
  }
  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 const'"); 
    }
  }
  
  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) 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) 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) (xmlParserNodeInfoSeqPtr)0 ;
  xmlNodePtr arg2 = (xmlNodePtr) (xmlNodePtr)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  unsigned long result;
  
  if(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 const""'"); 
  }
  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 const'"); 
    }
  }
  
  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) (xmlParserNodeInfoPtr)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if(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 const""'"); 
  }
  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) 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) 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) 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) 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 _wrap_XML_PARSE_RECOVER(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 _wrap_XML_PARSE_NOENT(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 _wrap_XML_PARSE_DTDLOAD(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 _wrap_XML_PARSE_DTDATTR(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 _wrap_XML_PARSE_DTDVALID(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 _wrap_XML_PARSE_NOERROR(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 _wrap_XML_PARSE_NOWARNING(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 _wrap_XML_PARSE_PEDANTIC(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 _wrap_XML_PARSE_NOBLANKS(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 _wrap_XML_PARSE_SAX1(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 _wrap_XML_PARSE_XINCLUDE(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 _wrap_XML_PARSE_NONET(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 _wrap_XML_PARSE_NODICT(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 _wrap_XML_PARSE_NSCLEAN(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 _wrap_XML_PARSE_NOCDATA(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 _wrap_XML_PARSE_NOXINCNODE(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 _wrap_XML_PARSE_COMPACT(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 _wrap_XML_PARSE_OLD10(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 _wrap_XML_PARSE_NOBASEFIX(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 _wrap_XML_PARSE_HUGE(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 _wrap_XML_PARSE_OLDSAX(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 _wrap_XML_PARSE_IGNORE_ENC(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 _wrap_XML_PARSE_BIG_LINES(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 _wrap_xmlCtxtReset(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if(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) 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_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) 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_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) 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) 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) 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) 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) 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_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) 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) 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) 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) 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) 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 _wrap_XML_WITH_THREAD(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 _wrap_XML_WITH_TREE(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 _wrap_XML_WITH_OUTPUT(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 _wrap_XML_WITH_PUSH(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 _wrap_XML_WITH_READER(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 _wrap_XML_WITH_PATTERN(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 _wrap_XML_WITH_WRITER(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 _wrap_XML_WITH_SAX1(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 _wrap_XML_WITH_FTP(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 _wrap_XML_WITH_HTTP(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 _wrap_XML_WITH_VALID(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 _wrap_XML_WITH_HTML(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 _wrap_XML_WITH_LEGACY(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 _wrap_XML_WITH_C14N(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 _wrap_XML_WITH_CATALOG(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 _wrap_XML_WITH_XPATH(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 _wrap_XML_WITH_XPTR(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 _wrap_XML_WITH_XINCLUDE(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 _wrap_XML_WITH_ICONV(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 _wrap_XML_WITH_ISO8859X(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 _wrap_XML_WITH_UNICODE(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 _wrap_XML_WITH_REGEXP(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 _wrap_XML_WITH_AUTOMATA(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 _wrap_XML_WITH_EXPR(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 _wrap_XML_WITH_SCHEMAS(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 _wrap_XML_WITH_SCHEMATRON(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 _wrap_XML_WITH_MODULES(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 _wrap_XML_WITH_DEBUG(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 _wrap_XML_WITH_DEBUG_MEM(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 _wrap_XML_WITH_DEBUG_RUN(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 _wrap_XML_WITH_ZLIB(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 _wrap_XML_WITH_ICU(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 _wrap_XML_WITH_LZMA(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 _wrap_XML_WITH_NONE(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) 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 _wrap_XPATH_EXPRESSION_OK(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 _wrap_XPATH_NUMBER_ERROR(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 _wrap_XPATH_UNFINISHED_LITERAL_ERROR(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 _wrap_XPATH_START_LITERAL_ERROR(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 _wrap_XPATH_VARIABLE_REF_ERROR(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 _wrap_XPATH_UNDEF_VARIABLE_ERROR(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 _wrap_XPATH_INVALID_PREDICATE_ERROR(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 _wrap_XPATH_EXPR_ERROR(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 _wrap_XPATH_UNCLOSED_ERROR(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 _wrap_XPATH_UNKNOWN_FUNC_ERROR(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 _wrap_XPATH_INVALID_OPERAND(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 _wrap_XPATH_INVALID_TYPE(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 _wrap_XPATH_INVALID_ARITY(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 _wrap_XPATH_INVALID_CTXT_SIZE(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 _wrap_XPATH_INVALID_CTXT_POSITION(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 _wrap_XPATH_MEMORY_ERROR(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 _wrap_XPTR_SYNTAX_ERROR(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 _wrap_XPTR_RESOURCE_ERROR(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 _wrap_XPTR_SUB_RESOURCE_ERROR(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 _wrap_XPATH_UNDEF_PREFIX_ERROR(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 _wrap_XPATH_ENCODING_ERROR(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 _wrap_XPATH_INVALID_CHAR_ERROR(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 _wrap_XPATH_INVALID_CTXT(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 _wrap_XPATH_STACK_ERROR(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 _wrap_XPATH_FORBID_VARIABLE_ERROR(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 _wrap_XPATH_OP_LIMIT_EXCEEDED(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 _wrap_XPATH_RECURSION_LIMIT_EXCEEDED(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) 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 _wrap_XPATH_UNDEFINED(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 _wrap_XPATH_NODESET(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 _wrap_XPATH_BOOLEAN(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 _wrap_XPATH_NUMBER(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 _wrap_XPATH_STRING(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 _wrap_XPATH_POINT(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  jsresult = SWIG_From_int(static_cast< int >(XPATH_POINT));
  
  SWIGV8_RETURN_INFO(jsresult, info);
  
  goto fail;
fail:
  SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
}


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


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


static SwigV8ReturnValue _wrap_XPATH_USERS(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 _wrap_XPATH_XSLT_TREE(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 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) 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) 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) 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) 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) 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 _wrap_XML_XPATH_CHECKNS(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 _wrap_XML_XPATH_NOVAR(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__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__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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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_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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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_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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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 _wrap_XML_CATA_PREFER_NONE(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 _wrap_XML_CATA_PREFER_PUBLIC(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 _wrap_XML_CATA_PREFER_SYSTEM(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 _wrap_XML_CATA_ALLOW_NONE(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 _wrap_XML_CATA_ALLOW_GLOBAL(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 _wrap_XML_CATA_ALLOW_DOCUMENT(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 _wrap_XML_CATA_ALLOW_ALL(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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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_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) 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) 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) 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) 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) 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) 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) 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) 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) 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_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) 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) 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) 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) 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_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) 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) 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) 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) 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) 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) 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) 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) 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) 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 _wrap_HTML_PARSE_RECOVER(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 _wrap_HTML_PARSE_NODEFDTD(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 _wrap_HTML_PARSE_NOERROR(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 _wrap_HTML_PARSE_NOWARNING(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 _wrap_HTML_PARSE_PEDANTIC(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 _wrap_HTML_PARSE_NOBLANKS(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 _wrap_HTML_PARSE_NONET(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 _wrap_HTML_PARSE_NOIMPLIED(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 _wrap_HTML_PARSE_COMPACT(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 _wrap_HTML_PARSE_IGNORE_ENC(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) 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) 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) 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) 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) 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) 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) 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_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) 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) 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) 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) 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) 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 _wrap_HTML_NA(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 _wrap_HTML_INVALID(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 _wrap_HTML_DEPRECATED(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 _wrap_HTML_VALID(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 _wrap_HTML_REQUIRED(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) 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) 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) 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) (htmlNodePtr)0 ;
  int arg2 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  htmlStatus result;
  
  if(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 const'"); 
    }
  }
  
  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 _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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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 void _wrap_xmlParserMaxDepth_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  
  ecode1 = SWIG_AsVal_unsigned_SS_int(value, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xmlParserMaxDepth_set" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  xmlParserMaxDepth = arg1;
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap_xmlParserMaxDepth_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  unsigned int result;
  
  result = (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 _wrap_XML_MAX_TEXT_LENGTH(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 _wrap_XML_MAX_NAME_LENGTH(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 _wrap_XML_MAX_DICTIONARY_LIMIT(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 _wrap_XML_MAX_LOOKUP_LIMIT(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 _wrap_XML_MAX_NAMELEN(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 _wrap_INPUT_CHUNK(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) 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) 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) 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) 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) 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_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) 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_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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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 _wrap_XML_SUBSTITUTE_NONE(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 _wrap_XML_SUBSTITUTE_REF(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 _wrap_XML_SUBSTITUTE_PEREF(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 _wrap_XML_SUBSTITUTE_BOTH(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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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 _wrap_htmlInitAutoClose(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  
  if(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_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) 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_xmlSetEntityReferenceFunc(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlEntityReferenceFunc arg1 = (xmlEntityReferenceFunc) 0 ;
  
  if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSetEntityReferenceFunc.");
  
  {
    int res = SWIG_ConvertFunctionPtr(args[0], (void**)(&arg1), SWIGTYPE_p_f_p__xmlEntity_p__xmlNode_p__xmlNode__void);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "xmlSetEntityReferenceFunc" "', argument " "1"" of type '" "xmlEntityReferenceFunc""'"); 
    }
  }
  xmlSetEntityReferenceFunc(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlParseQuotedString(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseQuotedString.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseQuotedString" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);
  result = (xmlChar *)xmlParseQuotedString(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_xmlParseNamespace(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParseNamespace.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParseNamespace" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);
  xmlParseNamespace(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNamespaceParseNSDef(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNamespaceParseNSDef.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNamespaceParseNSDef" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);
  result = (xmlChar *)xmlNamespaceParseNSDef(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_xmlScanName(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlScanName.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlScanName" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);
  result = (xmlChar *)xmlScanName(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_xmlNamespaceParseNCName(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNamespaceParseNCName.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNamespaceParseNCName" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);
  result = (xmlChar *)xmlNamespaceParseNCName(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_xmlParserHandleReference(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlParserHandleReference.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlParserHandleReference" "', argument " "1"" of type '" "xmlParserCtxtPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlParserCtxtPtr >(argp1);
  xmlParserHandleReference(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlNamespaceParseQName(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlNamespaceParseQName.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlNamespaceParseQName" "', 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 '" "xmlNamespaceParseQName" "', argument " "2"" of type '" "xmlChar **""'"); 
  }
  arg2 = reinterpret_cast< xmlChar ** >(argp2);
  result = (xmlChar *)xmlNamespaceParseQName(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_xmlDecodeEntities(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlParserCtxtPtr arg1 = (xmlParserCtxtPtr) 0 ;
  int arg2 ;
  int arg3 ;
  xmlChar arg4 ;
  xmlChar arg5 ;
  xmlChar arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlDecodeEntities.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlDecodeEntities" "', 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 '" "xmlDecodeEntities" "', 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 '" "xmlDecodeEntities" "', 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 '" "xmlDecodeEntities" "', 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 '" "xmlDecodeEntities" "', 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 '" "xmlDecodeEntities" "', argument " "6"" of type '" "xmlChar""'");
  } 
  arg6 = static_cast< xmlChar >(val6);
  result = (xmlChar *)xmlDecodeEntities(arg1,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_xmlHandleEntity(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 ;
  
  if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlHandleEntity.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlParserCtxt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlHandleEntity" "', 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 'xmlHandleEntity', argument 2 of type 'xmlEntityPtr'"); 
  }
  arg2 = (xmlEntityPtr) arg20;
  xmlHandleEntity(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_XML_PATTERN_DEFAULT(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 _wrap_XML_PATTERN_XPATH(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 _wrap_XML_PATTERN_XSSEL(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 _wrap_XML_PATTERN_XSFIELD(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) 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) 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) 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_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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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 _wrap_XML_RELAXNG_OK(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 _wrap_XML_RELAXNG_ERR_MEMORY(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 _wrap_XML_RELAXNG_ERR_TYPE(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 _wrap_XML_RELAXNG_ERR_TYPEVAL(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 _wrap_XML_RELAXNG_ERR_DUPID(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 _wrap_XML_RELAXNG_ERR_TYPECMP(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 _wrap_XML_RELAXNG_ERR_NOSTATE(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 _wrap_XML_RELAXNG_ERR_NODEFINE(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 _wrap_XML_RELAXNG_ERR_LISTEXTRA(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 _wrap_XML_RELAXNG_ERR_LISTEMPTY(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 _wrap_XML_RELAXNG_ERR_INTERNODATA(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 _wrap_XML_RELAXNG_ERR_INTERSEQ(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 _wrap_XML_RELAXNG_ERR_INTEREXTRA(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 _wrap_XML_RELAXNG_ERR_ELEMNAME(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 _wrap_XML_RELAXNG_ERR_ATTRNAME(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 _wrap_XML_RELAXNG_ERR_ELEMNONS(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 _wrap_XML_RELAXNG_ERR_ATTRNONS(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 _wrap_XML_RELAXNG_ERR_ELEMWRONGNS(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 _wrap_XML_RELAXNG_ERR_ATTRWRONGNS(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 _wrap_XML_RELAXNG_ERR_ELEMEXTRANS(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 _wrap_XML_RELAXNG_ERR_ATTREXTRANS(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 _wrap_XML_RELAXNG_ERR_ELEMNOTEMPTY(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 _wrap_XML_RELAXNG_ERR_NOELEM(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 _wrap_XML_RELAXNG_ERR_NOTELEM(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 _wrap_XML_RELAXNG_ERR_ATTRVALID(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 _wrap_XML_RELAXNG_ERR_CONTENTVALID(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 _wrap_XML_RELAXNG_ERR_EXTRACONTENT(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 _wrap_XML_RELAXNG_ERR_INVALIDATTR(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 _wrap_XML_RELAXNG_ERR_DATAELEM(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 _wrap_XML_RELAXNG_ERR_VALELEM(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 _wrap_XML_RELAXNG_ERR_LISTELEM(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 _wrap_XML_RELAXNG_ERR_DATATYPE(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 _wrap_XML_RELAXNG_ERR_VALUE(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 _wrap_XML_RELAXNG_ERR_LIST(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 _wrap_XML_RELAXNG_ERR_NOGRAMMAR(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 _wrap_XML_RELAXNG_ERR_EXTRADATA(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 _wrap_XML_RELAXNG_ERR_LACKDATA(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 _wrap_XML_RELAXNG_ERR_INTERNAL(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 _wrap_XML_RELAXNG_ERR_ELEMWRONG(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 _wrap_XML_RELAXNG_ERR_TEXTWRONG(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 _wrap_XML_RELAXNGP_NONE(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 _wrap_XML_RELAXNGP_FREE_DOC(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 _wrap_XML_RELAXNGP_CRNG(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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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__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) 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) 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) 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) 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) 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) 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) 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__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) 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) 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) 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) 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) 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) 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) 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 SwigV8ReturnValue _wrap_getPublicId(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *result = 0 ;
  
  if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_getPublicId.");
  
  arg1 = getSwigCObjectPtr(args[0]);
  result = (xmlChar *)getPublicId(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_getSystemId(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlChar *result = 0 ;
  
  if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_getSystemId.");
  
  arg1 = getSwigCObjectPtr(args[0]);
  result = (xmlChar *)getSystemId(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_setDocumentLocator(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_setDocumentLocator.");
  
  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 '" "setDocumentLocator" "', argument " "2"" of type '" "xmlSAXLocatorPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlSAXLocatorPtr >(argp2);
  setDocumentLocator(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


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


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


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


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


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


static SwigV8ReturnValue _wrap_internalSubset(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_internalSubset.");
  
  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 '" "internalSubset" "', 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 '" "internalSubset" "', 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 '" "internalSubset" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }
  internalSubset(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_externalSubset(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_externalSubset.");
  
  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 '" "externalSubset" "', 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 '" "externalSubset" "', 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 '" "externalSubset" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }
  externalSubset(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_getEntity(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_getEntity.");
  
  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 '" "getEntity" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }
  result = (xmlEntityPtr)getEntity(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_getParameterEntity(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_getParameterEntity.");
  
  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 '" "getParameterEntity" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }
  result = (xmlEntityPtr)getParameterEntity(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_resolveEntity(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_resolveEntity.");
  
  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 '" "resolveEntity" "', 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 '" "resolveEntity" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }
  result = (xmlParserInputPtr)resolveEntity(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_entityDecl(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_entityDecl.");
  
  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 '" "entityDecl" "', 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 '" "entityDecl" "', 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 '" "entityDecl" "', 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 '" "entityDecl" "', 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 '" "entityDecl" "', argument " "6"" of type '" "xmlChar *""'");
    }
    
    arg6 = reinterpret_cast< xmlChar * >(buf6);
  }
  entityDecl(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_attributeDecl(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_attributeDecl.");
  
  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 '" "attributeDecl" "', 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 '" "attributeDecl" "', 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 '" "attributeDecl" "', 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 '" "attributeDecl" "', 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 '" "attributeDecl" "', 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 '" "attributeDecl" "', argument " "7"" of type '" "xmlEnumerationPtr""'"); 
  }
  arg7 = reinterpret_cast< xmlEnumerationPtr >(argp7);
  attributeDecl(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_elementDecl(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_elementDecl.");
  
  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 '" "elementDecl" "', 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 '" "elementDecl" "', 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 '" "elementDecl" "', argument " "4"" of type '" "xmlElementContentPtr""'"); 
  }
  arg4 = reinterpret_cast< xmlElementContentPtr >(argp4);
  elementDecl(arg1,(unsigned char const *)arg2,arg3,arg4);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_notationDecl(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_notationDecl.");
  
  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 '" "notationDecl" "', 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 '" "notationDecl" "', 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 '" "notationDecl" "', argument " "4"" of type '" "xmlChar const *""'");
    }
    
    arg4 = reinterpret_cast< xmlChar * >(buf4);
  }
  notationDecl(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_unparsedEntityDecl(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_unparsedEntityDecl.");
  
  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 '" "unparsedEntityDecl" "', 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 '" "unparsedEntityDecl" "', 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 '" "unparsedEntityDecl" "', 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 '" "unparsedEntityDecl" "', argument " "5"" of type '" "xmlChar const *""'");
    }
    
    arg5 = reinterpret_cast< xmlChar * >(buf5);
  }
  unparsedEntityDecl(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_startDocument(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  
  if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_startDocument.");
  
  arg1 = getSwigCObjectPtr(args[0]);
  startDocument(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


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


static SwigV8ReturnValue _wrap_attribute(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_attribute.");
  
  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 '" "attribute" "', 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 '" "attribute" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }
  attribute(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_startElement(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_startElement.");
  
  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 '" "startElement" "', 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 '" "startElement" "', argument " "3"" of type '" "xmlChar const **""'"); 
  }
  arg3 = reinterpret_cast< xmlChar ** >(argp3);
  startElement(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_endElement(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_endElement.");
  
  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 '" "endElement" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }
  endElement(arg1,(unsigned char const *)arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_reference(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_reference.");
  
  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 '" "reference" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }
  reference(arg1,(unsigned char const *)arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_characters(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_characters.");
  
  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 '" "characters" "', 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 '" "characters" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  characters(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_ignorableWhitespace(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_ignorableWhitespace.");
  
  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 '" "ignorableWhitespace" "', 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 '" "ignorableWhitespace" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ignorableWhitespace(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_processingInstruction(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_processingInstruction.");
  
  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 '" "processingInstruction" "', 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 '" "processingInstruction" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }
  processingInstruction(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_globalNamespace(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_globalNamespace.");
  
  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 '" "globalNamespace" "', 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 '" "globalNamespace" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }
  globalNamespace(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_setNamespace(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_setNamespace.");
  
  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 '" "setNamespace" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }
  setNamespace(arg1,(unsigned char const *)arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_getNamespace(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  void *arg1 = (void *) 0 ;
  xmlNsPtr result;
  
  if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_getNamespace.");
  
  arg1 = getSwigCObjectPtr(args[0]);
  result = (xmlNsPtr)getNamespace(arg1);
  jsresult = createWrapNs(result, SWIGTYPE_p__xmlNs);
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_checkNamespace(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 ;
  int result;
  
  if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_checkNamespace.");
  
  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 '" "checkNamespace" "', argument " "2"" of type '" "xmlChar *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }
  result = (int)checkNamespace(arg1,arg2);
  jsresult = SWIG_From_int(static_cast< int >(result));
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_namespaceDecl(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_namespaceDecl.");
  
  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 '" "namespaceDecl" "', 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 '" "namespaceDecl" "', argument " "3"" of type '" "xmlChar const *""'");
    }
    
    arg3 = reinterpret_cast< xmlChar * >(buf3);
  }
  namespaceDecl(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_comment(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_comment.");
  
  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 '" "comment" "', argument " "2"" of type '" "xmlChar const *""'");
    }
    
    arg2 = reinterpret_cast< xmlChar * >(buf2);
  }
  comment(arg1,(unsigned char const *)arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_cdataBlock(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_cdataBlock.");
  
  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 '" "cdataBlock" "', 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 '" "cdataBlock" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  cdataBlock(arg1,(unsigned char const *)arg2,arg3);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


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


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


static SwigV8ReturnValue _wrap_initdocbDefaultSAXHandler(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlSAXHandlerV1 *arg1 = (xmlSAXHandlerV1 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_initdocbDefaultSAXHandler.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlSAXHandlerV1, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "initdocbDefaultSAXHandler" "', argument " "1"" of type '" "xmlSAXHandlerV1 *""'"); 
  }
  arg1 = reinterpret_cast< xmlSAXHandlerV1 * >(argp1);
  initdocbDefaultSAXHandler(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  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) 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) 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_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) 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_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) 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) 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_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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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_XML_MODULE_LAZY(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 _wrap_XML_MODULE_LOCAL(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) 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) 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) 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) 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 _wrap_XML_SCHEMAS_ERR_OK(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 _wrap_XML_SCHEMAS_ERR_NOROOT(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 _wrap_XML_SCHEMAS_ERR_UNDECLAREDELEM(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 _wrap_XML_SCHEMAS_ERR_NOTTOPLEVEL(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 _wrap_XML_SCHEMAS_ERR_MISSING(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 _wrap_XML_SCHEMAS_ERR_WRONGELEM(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 _wrap_XML_SCHEMAS_ERR_NOTYPE(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 _wrap_XML_SCHEMAS_ERR_NOROLLBACK(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 _wrap_XML_SCHEMAS_ERR_ISABSTRACT(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 _wrap_XML_SCHEMAS_ERR_NOTEMPTY(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 _wrap_XML_SCHEMAS_ERR_ELEMCONT(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 _wrap_XML_SCHEMAS_ERR_HAVEDEFAULT(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 _wrap_XML_SCHEMAS_ERR_NOTNILLABLE(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 _wrap_XML_SCHEMAS_ERR_EXTRACONTENT(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 _wrap_XML_SCHEMAS_ERR_INVALIDATTR(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 _wrap_XML_SCHEMAS_ERR_INVALIDELEM(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 _wrap_XML_SCHEMAS_ERR_NOTDETERMINIST(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 _wrap_XML_SCHEMAS_ERR_CONSTRUCT(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 _wrap_XML_SCHEMAS_ERR_INTERNAL(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 _wrap_XML_SCHEMAS_ERR_NOTSIMPLE(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 _wrap_XML_SCHEMAS_ERR_ATTRUNKNOWN(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 _wrap_XML_SCHEMAS_ERR_ATTRINVALID(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 _wrap_XML_SCHEMAS_ERR_VALUE(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 _wrap_XML_SCHEMAS_ERR_FACET(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 _wrap_XML_SCHEMAS_ERR_(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 _wrap_XML_SCHEMAS_ERR_XXX(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 _wrap_XML_SCHEMA_VAL_VC_I_CREATE(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) 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) 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) 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) 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) 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) 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__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) 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) 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) 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) 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) 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) 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) 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__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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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 _wrap_XML_PARSER_SEVERITY_VALIDITY_WARNING(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 _wrap_XML_PARSER_SEVERITY_VALIDITY_ERROR(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 _wrap_XML_PARSER_SEVERITY_WARNING(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 _wrap_XML_PARSER_SEVERITY_ERROR(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 _wrap_XML_SAVE_FORMAT(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 _wrap_XML_SAVE_NO_DECL(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 _wrap_XML_SAVE_NO_EMPTY(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 _wrap_XML_SAVE_NO_XHTML(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 _wrap_XML_SAVE_XHTML(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 _wrap_XML_SAVE_AS_XML(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 _wrap_XML_SAVE_AS_HTML(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 _wrap_XML_SAVE_WSNONSIG(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) 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) 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) 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) 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) 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) 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) 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) 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_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) 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) 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_XML_SCHEMAS_UNKNOWN(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 _wrap_XML_SCHEMAS_STRING(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 _wrap_XML_SCHEMAS_NORMSTRING(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 _wrap_XML_SCHEMAS_DECIMAL(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 _wrap_XML_SCHEMAS_TIME(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 _wrap_XML_SCHEMAS_GDAY(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 _wrap_XML_SCHEMAS_GMONTH(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 _wrap_XML_SCHEMAS_GMONTHDAY(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 _wrap_XML_SCHEMAS_GYEAR(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 _wrap_XML_SCHEMAS_GYEARMONTH(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 _wrap_XML_SCHEMAS_DATE(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 _wrap_XML_SCHEMAS_DATETIME(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 _wrap_XML_SCHEMAS_DURATION(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 _wrap_XML_SCHEMAS_FLOAT(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 _wrap_XML_SCHEMAS_DOUBLE(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 _wrap_XML_SCHEMAS_BOOLEAN(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 _wrap_XML_SCHEMAS_TOKEN(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 _wrap_XML_SCHEMAS_LANGUAGE(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 _wrap_XML_SCHEMAS_NMTOKEN(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 _wrap_XML_SCHEMAS_NMTOKENS(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 _wrap_XML_SCHEMAS_NAME(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 _wrap_XML_SCHEMAS_QNAME(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 _wrap_XML_SCHEMAS_NCNAME(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 _wrap_XML_SCHEMAS_ID(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 _wrap_XML_SCHEMAS_IDREF(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 _wrap_XML_SCHEMAS_IDREFS(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 _wrap_XML_SCHEMAS_ENTITY(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 _wrap_XML_SCHEMAS_ENTITIES(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 _wrap_XML_SCHEMAS_NOTATION(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 _wrap_XML_SCHEMAS_ANYURI(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 _wrap_XML_SCHEMAS_INTEGER(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 _wrap_XML_SCHEMAS_NPINTEGER(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 _wrap_XML_SCHEMAS_NINTEGER(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 _wrap_XML_SCHEMAS_NNINTEGER(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 _wrap_XML_SCHEMAS_PINTEGER(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 _wrap_XML_SCHEMAS_INT(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 _wrap_XML_SCHEMAS_UINT(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 _wrap_XML_SCHEMAS_LONG(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 _wrap_XML_SCHEMAS_ULONG(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 _wrap_XML_SCHEMAS_SHORT(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 _wrap_XML_SCHEMAS_USHORT(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 _wrap_XML_SCHEMAS_BYTE(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 _wrap_XML_SCHEMAS_UBYTE(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 _wrap_XML_SCHEMAS_HEXBINARY(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 _wrap_XML_SCHEMAS_BASE64BINARY(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 _wrap_XML_SCHEMAS_ANYTYPE(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 _wrap_XML_SCHEMAS_ANYSIMPLETYPE(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 _wrap_XML_SCHEMA_TYPE_BASIC(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 _wrap_XML_SCHEMA_TYPE_ANY(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 _wrap_XML_SCHEMA_TYPE_FACET(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 _wrap_XML_SCHEMA_TYPE_SIMPLE(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 _wrap_XML_SCHEMA_TYPE_COMPLEX(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 _wrap_XML_SCHEMA_TYPE_SEQUENCE(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 _wrap_XML_SCHEMA_TYPE_CHOICE(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 _wrap_XML_SCHEMA_TYPE_ALL(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 _wrap_XML_SCHEMA_TYPE_SIMPLE_CONTENT(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 _wrap_XML_SCHEMA_TYPE_COMPLEX_CONTENT(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 _wrap_XML_SCHEMA_TYPE_UR(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 _wrap_XML_SCHEMA_TYPE_RESTRICTION(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 _wrap_XML_SCHEMA_TYPE_EXTENSION(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 _wrap_XML_SCHEMA_TYPE_ELEMENT(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 _wrap_XML_SCHEMA_TYPE_ATTRIBUTE(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 _wrap_XML_SCHEMA_TYPE_ATTRIBUTEGROUP(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 _wrap_XML_SCHEMA_TYPE_GROUP(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 _wrap_XML_SCHEMA_TYPE_NOTATION(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 _wrap_XML_SCHEMA_TYPE_LIST(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 _wrap_XML_SCHEMA_TYPE_UNION(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 _wrap_XML_SCHEMA_TYPE_ANY_ATTRIBUTE(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 _wrap_XML_SCHEMA_TYPE_IDC_UNIQUE(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 _wrap_XML_SCHEMA_TYPE_IDC_KEY(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 _wrap_XML_SCHEMA_TYPE_IDC_KEYREF(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 _wrap_XML_SCHEMA_TYPE_PARTICLE(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 _wrap_XML_SCHEMA_TYPE_ATTRIBUTE_USE(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 _wrap_XML_SCHEMA_FACET_MININCLUSIVE(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 _wrap_XML_SCHEMA_FACET_MINEXCLUSIVE(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 _wrap_XML_SCHEMA_FACET_MAXINCLUSIVE(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 _wrap_XML_SCHEMA_FACET_MAXEXCLUSIVE(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 _wrap_XML_SCHEMA_FACET_TOTALDIGITS(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 _wrap_XML_SCHEMA_FACET_FRACTIONDIGITS(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 _wrap_XML_SCHEMA_FACET_PATTERN(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 _wrap_XML_SCHEMA_FACET_ENUMERATION(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 _wrap_XML_SCHEMA_FACET_WHITESPACE(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 _wrap_XML_SCHEMA_FACET_LENGTH(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 _wrap_XML_SCHEMA_FACET_MAXLENGTH(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 _wrap_XML_SCHEMA_FACET_MINLENGTH(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 _wrap_XML_SCHEMA_EXTRA_QNAMEREF(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 _wrap_XML_SCHEMA_EXTRA_ATTR_USE_PROHIB(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 _wrap_XML_SCHEMA_CONTENT_UNKNOWN(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 _wrap_XML_SCHEMA_CONTENT_EMPTY(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 _wrap_XML_SCHEMA_CONTENT_ELEMENTS(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 _wrap_XML_SCHEMA_CONTENT_MIXED(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 _wrap_XML_SCHEMA_CONTENT_SIMPLE(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 _wrap_XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS(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 _wrap_XML_SCHEMA_CONTENT_BASIC(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 _wrap_XML_SCHEMA_CONTENT_ANY(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) 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 _wrap_XML_SCHEMAS_ANYATTR_SKIP(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 _wrap_XML_SCHEMAS_ANYATTR_LAX(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 _wrap_XML_SCHEMAS_ANYATTR_STRICT(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_XML_SCHEMAS_ANY_SKIP(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 _wrap_XML_SCHEMAS_ANY_LAX(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 _wrap_XML_SCHEMAS_ANY_STRICT(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_XML_SCHEMAS_ATTR_USE_PROHIBITED(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 _wrap_XML_SCHEMAS_ATTR_USE_REQUIRED(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 _wrap_XML_SCHEMAS_ATTR_USE_OPTIONAL(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 _wrap_XML_SCHEMAS_ATTR_GLOBAL(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 _wrap_XML_SCHEMAS_ATTR_NSDEFAULT(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 _wrap_XML_SCHEMAS_ATTR_INTERNAL_RESOLVED(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 _wrap_XML_SCHEMAS_ATTR_FIXED(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) 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) 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 _wrap_XML_SCHEMAS_WILDCARD_COMPLETE(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) 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) 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 _wrap_XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED(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 _wrap_XML_SCHEMAS_ATTRGROUP_GLOBAL(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 _wrap_XML_SCHEMAS_ATTRGROUP_MARKED(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 _wrap_XML_SCHEMAS_ATTRGROUP_REDEFINED(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 _wrap_XML_SCHEMAS_ATTRGROUP_HAS_REFS(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) 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) 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) 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 _wrap_XML_SCHEMAS_TYPE_MIXED(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 _wrap_XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION(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 _wrap_XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION(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 _wrap_XML_SCHEMAS_TYPE_GLOBAL(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 _wrap_XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD(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 _wrap_XML_SCHEMAS_TYPE_VARIETY_ABSENT(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 _wrap_XML_SCHEMAS_TYPE_VARIETY_LIST(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 _wrap_XML_SCHEMAS_TYPE_VARIETY_UNION(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 _wrap_XML_SCHEMAS_TYPE_VARIETY_ATOMIC(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 _wrap_XML_SCHEMAS_TYPE_FINAL_EXTENSION(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 _wrap_XML_SCHEMAS_TYPE_FINAL_RESTRICTION(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 _wrap_XML_SCHEMAS_TYPE_FINAL_LIST(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 _wrap_XML_SCHEMAS_TYPE_FINAL_UNION(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 _wrap_XML_SCHEMAS_TYPE_FINAL_DEFAULT(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 _wrap_XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE(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 _wrap_XML_SCHEMAS_TYPE_MARKED(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 _wrap_XML_SCHEMAS_TYPE_BLOCK_DEFAULT(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 _wrap_XML_SCHEMAS_TYPE_BLOCK_EXTENSION(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 _wrap_XML_SCHEMAS_TYPE_BLOCK_RESTRICTION(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 _wrap_XML_SCHEMAS_TYPE_ABSTRACT(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 _wrap_XML_SCHEMAS_TYPE_FACETSNEEDVALUE(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 _wrap_XML_SCHEMAS_TYPE_INTERNAL_RESOLVED(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 _wrap_XML_SCHEMAS_TYPE_INTERNAL_INVALID(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 _wrap_XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE(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 _wrap_XML_SCHEMAS_TYPE_WHITESPACE_REPLACE(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 _wrap_XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE(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 _wrap_XML_SCHEMAS_TYPE_HAS_FACETS(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 _wrap_XML_SCHEMAS_TYPE_NORMVALUENEEDED(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 _wrap_XML_SCHEMAS_TYPE_FIXUP_1(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 _wrap_XML_SCHEMAS_TYPE_REDEFINED(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) 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 _wrap_XML_SCHEMAS_ELEM_NILLABLE(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 _wrap_XML_SCHEMAS_ELEM_GLOBAL(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 _wrap_XML_SCHEMAS_ELEM_DEFAULT(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 _wrap_XML_SCHEMAS_ELEM_FIXED(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 _wrap_XML_SCHEMAS_ELEM_ABSTRACT(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 _wrap_XML_SCHEMAS_ELEM_TOPLEVEL(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 _wrap_XML_SCHEMAS_ELEM_REF(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 _wrap_XML_SCHEMAS_ELEM_NSDEFAULT(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 _wrap_XML_SCHEMAS_ELEM_INTERNAL_RESOLVED(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 _wrap_XML_SCHEMAS_ELEM_CIRCULAR(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 _wrap_XML_SCHEMAS_ELEM_BLOCK_ABSENT(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 _wrap_XML_SCHEMAS_ELEM_BLOCK_EXTENSION(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 _wrap_XML_SCHEMAS_ELEM_BLOCK_RESTRICTION(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 _wrap_XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION(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 _wrap_XML_SCHEMAS_ELEM_FINAL_ABSENT(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 _wrap_XML_SCHEMAS_ELEM_FINAL_EXTENSION(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 _wrap_XML_SCHEMAS_ELEM_FINAL_RESTRICTION(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 _wrap_XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD(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 _wrap_XML_SCHEMAS_ELEM_INTERNAL_CHECKED(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) 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 _wrap_XML_SCHEMAS_FACET_UNKNOWN(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 _wrap_XML_SCHEMAS_FACET_PRESERVE(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 _wrap_XML_SCHEMAS_FACET_REPLACE(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 _wrap_XML_SCHEMAS_FACET_COLLAPSE(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) 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) 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 _wrap_XML_SCHEMAS_QUALIF_ELEM(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 _wrap_XML_SCHEMAS_QUALIF_ATTR(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 _wrap_XML_SCHEMAS_FINAL_DEFAULT_EXTENSION(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 _wrap_XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION(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 _wrap_XML_SCHEMAS_FINAL_DEFAULT_LIST(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 _wrap_XML_SCHEMAS_FINAL_DEFAULT_UNION(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 _wrap_XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION(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 _wrap_XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION(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 _wrap_XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION(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 _wrap_XML_SCHEMAS_INCLUDING_CONVERT_NS(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) 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) 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) 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 _wrap_XML_SCHEMA_WHITESPACE_UNKNOWN(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 _wrap_XML_SCHEMA_WHITESPACE_PRESERVE(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 _wrap_XML_SCHEMA_WHITESPACE_REPLACE(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 _wrap_XML_SCHEMA_WHITESPACE_COLLAPSE(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;
  
  if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlSchemaInitTypes.");
  
  xmlSchemaInitTypes();
  jsresult = SWIGV8_UNDEFINED();
  
  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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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 void _wrap__xmlLocationSet_locNr_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlLocationSet *arg1 = (_xmlLocationSet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlLocationSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlLocationSet_locNr_set" "', argument " "1"" of type '" "_xmlLocationSet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlLocationSet * >(argp1);
  ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlLocationSet_locNr_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->locNr = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlLocationSet_locNr_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlLocationSet *arg1 = (_xmlLocationSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlLocationSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlLocationSet_locNr_get" "', argument " "1"" of type '" "_xmlLocationSet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlLocationSet * >(argp1);
  result = (int) ((arg1)->locNr);
  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__xmlLocationSet_locMax_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlLocationSet *arg1 = (_xmlLocationSet *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlLocationSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlLocationSet_locMax_set" "', argument " "1"" of type '" "_xmlLocationSet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlLocationSet * >(argp1);
  ecode2 = SWIG_AsVal_int(value, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_xmlLocationSet_locMax_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->locMax = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlLocationSet_locMax_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlLocationSet *arg1 = (_xmlLocationSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlLocationSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlLocationSet_locMax_get" "', argument " "1"" of type '" "_xmlLocationSet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlLocationSet * >(argp1);
  result = (int) ((arg1)->locMax);
  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__xmlLocationSet_locTab_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  SWIGV8_HANDLESCOPE();
  
  _xmlLocationSet *arg1 = (_xmlLocationSet *) 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__xmlLocationSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlLocationSet_locTab_set" "', argument " "1"" of type '" "_xmlLocationSet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlLocationSet * >(argp1);
  res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_xmlLocationSet_locTab_set" "', argument " "2"" of type '" "xmlXPathObjectPtr *""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathObjectPtr * >(argp2);
  if (arg1) (arg1)->locTab = arg2;
  
  
  
  goto fail;
fail:
  return;
}


static SwigV8ReturnValue _wrap__xmlLocationSet_locTab_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  _xmlLocationSet *arg1 = (_xmlLocationSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathObjectPtr *result = 0 ;
  
  res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p__xmlLocationSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_xmlLocationSet_locTab_get" "', argument " "1"" of type '" "_xmlLocationSet *""'"); 
  }
  arg1 = reinterpret_cast< _xmlLocationSet * >(argp1);
  result = (xmlXPathObjectPtr *) ((arg1)->locTab);
  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 SwigV8ReturnValue _wrap_new__xmlLocationSet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_OBJECT self = args.Holder();
  _xmlLocationSet *result;
  if(self->InternalFieldCount() < 1) SWIG_exception_fail(SWIG_ERROR, "Illegal call of constructor _wrap_new__xmlLocationSet.");
  if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new__xmlLocationSet.");
  result = (_xmlLocationSet *)new _xmlLocationSet();
  
  
  
  SWIGV8_SetPrivateData(self, result, SWIGTYPE_p__xmlLocationSet, SWIG_POINTER_OWN);
  SWIGV8_RETURN(self);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


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


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


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


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


static SwigV8ReturnValue _wrap_xmlXPtrNewRange(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int arg2 ;
  xmlNodePtr arg3 = (xmlNodePtr) 0 ;
  int arg4 ;
  int res1 ;
  void *arg10 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  void *arg30 ;
  int val4 ;
  int ecode4 = 0 ;
  xmlXPathObjectPtr result;
  
  if(args.Length() != 4) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPtrNewRange.");
  
  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 'xmlXPtrNewRange', 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 '" "xmlXPtrNewRange" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  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 'xmlXPtrNewRange', 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 '" "xmlXPtrNewRange" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  result = (xmlXPathObjectPtr)xmlXPtrNewRange(arg1,arg2,arg3,arg4);
  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_xmlXPtrNewRangePoints(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathObjectPtr arg1 = (xmlXPathObjectPtr) 0 ;
  xmlXPathObjectPtr arg2 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlXPathObjectPtr result;
  
  if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPtrNewRangePoints.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPtrNewRangePoints" "', argument " "1"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathObjectPtr >(argp1);
  res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPtrNewRangePoints" "', argument " "2"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathObjectPtr >(argp2);
  result = (xmlXPathObjectPtr)xmlXPtrNewRangePoints(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_xmlXPtrNewRangeNodePoint(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlXPathObjectPtr arg2 = (xmlXPathObjectPtr) 0 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlXPathObjectPtr result;
  
  if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPtrNewRangeNodePoint.");
  
  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 'xmlXPtrNewRangeNodePoint', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);
  res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPtrNewRangeNodePoint" "', argument " "2"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathObjectPtr >(argp2);
  result = (xmlXPathObjectPtr)xmlXPtrNewRangeNodePoint(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_xmlXPtrNewRangePointNode(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathObjectPtr arg1 = (xmlXPathObjectPtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *arg20 ;
  xmlXPathObjectPtr result;
  
  if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPtrNewRangePointNode.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPtrNewRangePointNode" "', argument " "1"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathObjectPtr >(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 'xmlXPtrNewRangePointNode', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);
  result = (xmlXPathObjectPtr)xmlXPtrNewRangePointNode(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_xmlXPtrNewRangeNodes(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  xmlXPathObjectPtr result;
  
  if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPtrNewRangeNodes.");
  
  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 'xmlXPtrNewRangeNodes', 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 'xmlXPtrNewRangeNodes', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);
  result = (xmlXPathObjectPtr)xmlXPtrNewRangeNodes(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_xmlXPtrNewLocationSetNodes(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlNodePtr arg2 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  int res2 ;
  void *arg20 ;
  xmlXPathObjectPtr result;
  
  if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPtrNewLocationSetNodes.");
  
  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 'xmlXPtrNewLocationSetNodes', 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 'xmlXPtrNewLocationSetNodes', argument 2 of type 'xmlNodePtr'"); 
    }
  }
  
  arg2 = ((xmlNodePtr) arg20);
  result = (xmlXPathObjectPtr)xmlXPtrNewLocationSetNodes(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_xmlXPtrNewLocationSetNodeSet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodeSetPtr arg1 = (xmlNodeSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathObjectPtr result;
  
  if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPtrNewLocationSetNodeSet.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlNodeSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPtrNewLocationSetNodeSet" "', argument " "1"" of type '" "xmlNodeSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlNodeSetPtr >(argp1);
  result = (xmlXPathObjectPtr)xmlXPtrNewLocationSetNodeSet(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_xmlXPtrNewRangeNodeObject(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  xmlXPathObjectPtr arg2 = (xmlXPathObjectPtr) 0 ;
  int res1 ;
  void *arg10 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  xmlXPathObjectPtr result;
  
  if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPtrNewRangeNodeObject.");
  
  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 'xmlXPtrNewRangeNodeObject', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);
  res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPtrNewRangeNodeObject" "', argument " "2"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathObjectPtr >(argp2);
  result = (xmlXPathObjectPtr)xmlXPtrNewRangeNodeObject(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_xmlXPtrNewCollapsedRange(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlNodePtr arg1 = (xmlNodePtr) 0 ;
  int res1 ;
  void *arg10 ;
  xmlXPathObjectPtr result;
  
  if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPtrNewCollapsedRange.");
  
  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 'xmlXPtrNewCollapsedRange', argument 1 of type 'xmlNodePtr'"); 
    }
  }
  
  arg1 = ((xmlNodePtr) arg10);
  result = (xmlXPathObjectPtr)xmlXPtrNewCollapsedRange(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_xmlXPtrLocationSetAdd(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlLocationSetPtr arg1 = (xmlLocationSetPtr) 0 ;
  xmlXPathObjectPtr arg2 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPtrLocationSetAdd.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlLocationSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPtrLocationSetAdd" "', argument " "1"" of type '" "xmlLocationSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlLocationSetPtr >(argp1);
  res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPtrLocationSetAdd" "', argument " "2"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathObjectPtr >(argp2);
  xmlXPtrLocationSetAdd(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPtrWrapLocationSet(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlLocationSetPtr arg1 = (xmlLocationSetPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  xmlXPathObjectPtr result;
  
  if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPtrWrapLocationSet.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlLocationSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPtrWrapLocationSet" "', argument " "1"" of type '" "xmlLocationSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlLocationSetPtr >(argp1);
  result = (xmlXPathObjectPtr)xmlXPtrWrapLocationSet(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_xmlXPtrLocationSetDel(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlLocationSetPtr arg1 = (xmlLocationSetPtr) 0 ;
  xmlXPathObjectPtr arg2 = (xmlXPathObjectPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPtrLocationSetDel.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlLocationSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPtrLocationSetDel" "', argument " "1"" of type '" "xmlLocationSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlLocationSetPtr >(argp1);
  res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p__xmlXPathObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xmlXPtrLocationSetDel" "', argument " "2"" of type '" "xmlXPathObjectPtr""'"); 
  }
  arg2 = reinterpret_cast< xmlXPathObjectPtr >(argp2);
  xmlXPtrLocationSetDel(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


static SwigV8ReturnValue _wrap_xmlXPtrLocationSetRemove(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlLocationSetPtr arg1 = (xmlLocationSetPtr) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPtrLocationSetRemove.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlLocationSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPtrLocationSetRemove" "', argument " "1"" of type '" "xmlLocationSetPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlLocationSetPtr >(argp1);
  ecode2 = SWIG_AsVal_int(args[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xmlXPtrLocationSetRemove" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  xmlXPtrLocationSetRemove(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  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) 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) 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());
}


static SwigV8ReturnValue _wrap_xmlXPtrRangeToFunction(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) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPtrRangeToFunction.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPtrRangeToFunction" "', 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 '" "xmlXPtrRangeToFunction" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  xmlXPtrRangeToFunction(arg1,arg2);
  jsresult = SWIGV8_UNDEFINED();
  
  
  
  SWIGV8_RETURN(jsresult);
  
  goto fail;
fail:
  SWIGV8_RETURN(SWIGV8_UNDEFINED());
}


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


static SwigV8ReturnValue _wrap_xmlXPtrEvalRangePredicate(const SwigV8Arguments &args) {
  SWIGV8_HANDLESCOPE();
  
  SWIGV8_VALUE jsresult;
  xmlXPathParserContextPtr arg1 = (xmlXPathParserContextPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_xmlXPtrEvalRangePredicate.");
  
  res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p__xmlXPathParserContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xmlXPtrEvalRangePredicate" "', argument " "1"" of type '" "xmlXPathParserContextPtr""'"); 
  }
  arg1 = reinterpret_cast< xmlXPathParserContextPtr >(argp1);
  xmlXPtrEvalRangePredicate(arg1);
  jsresult = SWIGV8_UNDEFINED();
  
  
  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__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__xmlExpCtxt = {"_p__xmlExpCtxt", "xmlExpCtxt *|xmlExpCtxtPtr|_xmlExpCtxt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__xmlExpNode = {"_p__xmlExpNode", "xmlExpNode *|xmlExpNodePtr|_xmlExpNode *", 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__xmlLocationSet = {"_p__xmlLocationSet", "p__xmlLocationSet|xmlLocationSet *|xmlLocationSetPtr|_xmlLocationSet *", 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__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__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__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__xmlEntity_p__xmlNode_p__xmlNode__void = {"_p_f_p__xmlEntity_p__xmlNode_p__xmlNode__void", "xmlEntityReferenceFunc|void (*)(_xmlEntity *,_xmlNode *,_xmlNode *)", 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__xmlError__void = {"_p_f_p_void_p__xmlError__void", "xmlStructuredErrorFunc|void (*)(void *,_xmlError *)", 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__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_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p__xmlDoc = {"_p_p__xmlDoc", "htmlDocPtr *|_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__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__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__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__xmlError__void = {"_p_p_f_p_void_p__xmlError__void", "xmlStructuredErrorFunc *|void (**)(void *,_xmlError *)", 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_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_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_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_xmlExpNodeType = {"_p_xmlExpNodeType", "xmlExpNodeType *|enum xmlExpNodeType *", 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_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_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_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__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__xmlExpCtxt,
  &_swigt__p__xmlExpNode,
  &_swigt__p__xmlGlobalState,
  &_swigt__p__xmlHashTable,
  &_swigt__p__xmlID,
  &_swigt__p__xmlLink,
  &_swigt__p__xmlList,
  &_swigt__p__xmlLocationSet,
  &_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__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__xmlURI,
  &_swigt__p__xmlValidCtxt,
  &_swigt__p__xmlValidState,
  &_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__xmlEntity_p__xmlNode_p__xmlNode__void,
  &_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__xmlError__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__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_int,
  &_swigt__p_p__xmlDoc,
  &_swigt__p_p__xmlElementContent,
  &_swigt__p_p__xmlEnumeration,
  &_swigt__p_p__xmlNode,
  &_swigt__p_p__xmlNs,
  &_swigt__p_p__xmlParserCtxt,
  &_swigt__p_p__xmlParserInput,
  &_swigt__p_p__xmlSAXHandler,
  &_swigt__p_p__xmlSchemaAttributeLink,
  &_swigt__p_p__xmlSchemaVal,
  &_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__xmlError__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_unsigned_char,
  &_swigt__p_p_void,
  &_swigt__p_unsigned_char,
  &_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_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_xmlExpNodeType,
  &_swigt__p_xmlFeature,
  &_swigt__p_xmlModuleOption,
  &_swigt__p_xmlParserErrors,
  &_swigt__p_xmlParserInputState,
  &_swigt__p_xmlParserMode,
  &_swigt__p_xmlParserOption,
  &_swigt__p_xmlParserSeverities,
  &_swigt__p_xmlPatternFlags,
  &_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_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__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__xmlExpCtxt[] = {  {&_swigt__p__xmlExpCtxt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__xmlExpNode[] = {  {&_swigt__p__xmlExpNode, 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__xmlLocationSet[] = {  {&_swigt__p__xmlLocationSet, 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__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__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__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__xmlEntity_p__xmlNode_p__xmlNode__void[] = {  {&_swigt__p_f_p__xmlEntity_p__xmlNode_p__xmlNode__void, 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__xmlError__void[] = {  {&_swigt__p_f_p_void_p__xmlError__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__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_int[] = {  {&_swigt__p_int, 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__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__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__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__xmlError__void[] = {  {&_swigt__p_p_f_p_void_p__xmlError__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_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_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_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_xmlExpNodeType[] = {  {&_swigt__p_xmlExpNodeType, 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_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_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_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__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__xmlExpCtxt,
  _swigc__p__xmlExpNode,
  _swigc__p__xmlGlobalState,
  _swigc__p__xmlHashTable,
  _swigc__p__xmlID,
  _swigc__p__xmlLink,
  _swigc__p__xmlList,
  _swigc__p__xmlLocationSet,
  _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__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__xmlURI,
  _swigc__p__xmlValidCtxt,
  _swigc__p__xmlValidState,
  _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__xmlEntity_p__xmlNode_p__xmlNode__void,
  _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__xmlError__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__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_int,
  _swigc__p_p__xmlDoc,
  _swigc__p_p__xmlElementContent,
  _swigc__p_p__xmlEnumeration,
  _swigc__p_p__xmlNode,
  _swigc__p_p__xmlNs,
  _swigc__p_p__xmlParserCtxt,
  _swigc__p_p__xmlParserInput,
  _swigc__p_p__xmlSAXHandler,
  _swigc__p_p__xmlSchemaAttributeLink,
  _swigc__p_p__xmlSchemaVal,
  _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__xmlError__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_unsigned_char,
  _swigc__p_p_void,
  _swigc__p_unsigned_char,
  _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_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_xmlExpNodeType,
  _swigc__p_xmlFeature,
  _swigc__p_xmlModuleOption,
  _swigc__p_xmlParserErrors,
  _swigc__p_xmlParserInputState,
  _swigc__p_xmlParserMode,
  _swigc__p_xmlParserOption,
  _swigc__p_xmlParserSeverities,
  _swigc__p_xmlPatternFlags,
  _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_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__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__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__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__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__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__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;
}
/* Name: _exports__xmlLocationSet, Type: p__xmlLocationSet, Dtor: _wrap_delete__xmlLocationSet */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlLocationSet_class = SWIGV8_CreateClassTemplate("_exports__xmlLocationSet");
SWIGV8_SET_CLASS_TEMPL(_exports__xmlLocationSet_clientData.class_templ, _exports__xmlLocationSet_class);
_exports__xmlLocationSet_clientData.dtor = _wrap_delete__xmlLocationSet;
if (SWIGTYPE_p__xmlLocationSet->clientdata == 0) {
  SWIGTYPE_p__xmlLocationSet->clientdata = &_exports__xmlLocationSet_clientData;
}


  /* register wrapper functions */
  SWIGV8_AddStaticVariable(exports_obj, "libxmljs_debug", _wrap_libxmljs_debug_get, _wrap_libxmljs_debug_set, context);
SWIGV8_AddStaticVariable(exports_obj, "ATTRIBUTE_DESTRUCTOR", _wrap_ATTRIBUTE_DESTRUCTOR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_ARPA_INET_H", _wrap_HAVE_ARPA_INET_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_ARPA_NAMESER_H", _wrap_HAVE_ARPA_NAMESER_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_CTYPE_H", _wrap_HAVE_CTYPE_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_DIRENT_H", _wrap_HAVE_DIRENT_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_DLFCN_H", _wrap_HAVE_DLFCN_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_ERRNO_H", _wrap_HAVE_ERRNO_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_FCNTL_H", _wrap_HAVE_FCNTL_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_FLOAT_H", _wrap_HAVE_FLOAT_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_FPRINTF", _wrap_HAVE_FPRINTF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_FTIME", _wrap_HAVE_FTIME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_GETTIMEOFDAY", _wrap_HAVE_GETTIMEOFDAY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_INTTYPES_H", _wrap_HAVE_INTTYPES_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_ISASCII", _wrap_HAVE_ISASCII, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_LIMITS_H", _wrap_HAVE_LIMITS_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_LOCALTIME", _wrap_HAVE_LOCALTIME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_MATH_H", _wrap_HAVE_MATH_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_MEMORY_H", _wrap_HAVE_MEMORY_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_MMAP", _wrap_HAVE_MMAP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_MUNMAP", _wrap_HAVE_MUNMAP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_NETDB_H", _wrap_HAVE_NETDB_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_NETINET_IN_H", _wrap_HAVE_NETINET_IN_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_POLL_H", _wrap_HAVE_POLL_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_PRINTF", _wrap_HAVE_PRINTF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_PUTENV", _wrap_HAVE_PUTENV, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_RAND", _wrap_HAVE_RAND, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_RESOLV_H", _wrap_HAVE_RESOLV_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SIGNAL", _wrap_HAVE_SIGNAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SIGNAL_H", _wrap_HAVE_SIGNAL_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SNPRINTF", _wrap_HAVE_SNPRINTF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SPRINTF", _wrap_HAVE_SPRINTF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SRAND", _wrap_HAVE_SRAND, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SSCANF", _wrap_HAVE_SSCANF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_STAT", _wrap_HAVE_STAT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_STDARG_H", _wrap_HAVE_STDARG_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_STDINT_H", _wrap_HAVE_STDINT_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_STDLIB_H", _wrap_HAVE_STDLIB_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_STRFTIME", _wrap_HAVE_STRFTIME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_STRINGS_H", _wrap_HAVE_STRINGS_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_STRING_H", _wrap_HAVE_STRING_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SYS_MMAN_H", _wrap_HAVE_SYS_MMAN_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SYS_SELECT_H", _wrap_HAVE_SYS_SELECT_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SYS_SOCKET_H", _wrap_HAVE_SYS_SOCKET_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SYS_STAT_H", _wrap_HAVE_SYS_STAT_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SYS_TIMEB_H", _wrap_HAVE_SYS_TIMEB_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SYS_TIME_H", _wrap_HAVE_SYS_TIME_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_SYS_TYPES_H", _wrap_HAVE_SYS_TYPES_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_TIME", _wrap_HAVE_TIME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_TIME_H", _wrap_HAVE_TIME_H, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_VFPRINTF", _wrap_HAVE_VFPRINTF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_VSNPRINTF", _wrap_HAVE_VSNPRINTF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HAVE_VSPRINTF", _wrap_HAVE_VSPRINTF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "LT_OBJDIR", _wrap_LT_OBJDIR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "PACKAGE", _wrap_PACKAGE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "PACKAGE_BUGREPORT", _wrap_PACKAGE_BUGREPORT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "PACKAGE_NAME", _wrap_PACKAGE_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "PACKAGE_STRING", _wrap_PACKAGE_STRING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "PACKAGE_TARNAME", _wrap_PACKAGE_TARNAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "PACKAGE_URL", _wrap_PACKAGE_URL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "PACKAGE_VERSION", _wrap_PACKAGE_VERSION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "STDC_HEADERS", _wrap_STDC_HEADERS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "VA_LIST_IS_ARRAY", _wrap_VA_LIST_IS_ARRAY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "VERSION", _wrap_VERSION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "LIBXML_DOTTED_VERSION", _wrap_LIBXML_DOTTED_VERSION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "LIBXML_VERSION", _wrap_LIBXML_VERSION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "LIBXML_VERSION_STRING", _wrap_LIBXML_VERSION_STRING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "LIBXML_VERSION_EXTRA", _wrap_LIBXML_VERSION_EXTRA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "LIBXML_MODULE_EXTENSION", _wrap_LIBXML_MODULE_EXTENSION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "BASE_BUFFER_SIZE", _wrap_BASE_BUFFER_SIZE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_BUFFER_ALLOC_DOUBLEIT", _wrap_XML_BUFFER_ALLOC_DOUBLEIT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_BUFFER_ALLOC_EXACT", _wrap_XML_BUFFER_ALLOC_EXACT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_BUFFER_ALLOC_IMMUTABLE", _wrap_XML_BUFFER_ALLOC_IMMUTABLE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_BUFFER_ALLOC_IO", _wrap_XML_BUFFER_ALLOC_IO, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_BUFFER_ALLOC_HYBRID", _wrap_XML_BUFFER_ALLOC_HYBRID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_BUFFER_ALLOC_BOUNDED", _wrap_XML_BUFFER_ALLOC_BOUNDED, 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", _wrap_XML_ELEMENT_NODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_NODE", _wrap_XML_ATTRIBUTE_NODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_TEXT_NODE", _wrap_XML_TEXT_NODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CDATA_SECTION_NODE", _wrap_XML_CDATA_SECTION_NODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ENTITY_REF_NODE", _wrap_XML_ENTITY_REF_NODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ENTITY_NODE", _wrap_XML_ENTITY_NODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PI_NODE", _wrap_XML_PI_NODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_COMMENT_NODE", _wrap_XML_COMMENT_NODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOCUMENT_NODE", _wrap_XML_DOCUMENT_NODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOCUMENT_TYPE_NODE", _wrap_XML_DOCUMENT_TYPE_NODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOCUMENT_FRAG_NODE", _wrap_XML_DOCUMENT_FRAG_NODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_NOTATION_NODE", _wrap_XML_NOTATION_NODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_HTML_DOCUMENT_NODE", _wrap_XML_HTML_DOCUMENT_NODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NODE", _wrap_XML_DTD_NODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_DECL", _wrap_XML_ELEMENT_DECL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_DECL", _wrap_XML_ATTRIBUTE_DECL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ENTITY_DECL", _wrap_XML_ENTITY_DECL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_NAMESPACE_DECL", _wrap_XML_NAMESPACE_DECL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_START", _wrap_XML_XINCLUDE_START, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_END", _wrap_XML_XINCLUDE_END, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOCB_DOCUMENT_NODE", _wrap_XML_DOCB_DOCUMENT_NODE, 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", _wrap_XML_ATTRIBUTE_CDATA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_ID", _wrap_XML_ATTRIBUTE_ID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_IDREF", _wrap_XML_ATTRIBUTE_IDREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_IDREFS", _wrap_XML_ATTRIBUTE_IDREFS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_ENTITY", _wrap_XML_ATTRIBUTE_ENTITY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_ENTITIES", _wrap_XML_ATTRIBUTE_ENTITIES, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_NMTOKEN", _wrap_XML_ATTRIBUTE_NMTOKEN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_NMTOKENS", _wrap_XML_ATTRIBUTE_NMTOKENS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_ENUMERATION", _wrap_XML_ATTRIBUTE_ENUMERATION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_NOTATION", _wrap_XML_ATTRIBUTE_NOTATION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_NONE", _wrap_XML_ATTRIBUTE_NONE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_REQUIRED", _wrap_XML_ATTRIBUTE_REQUIRED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_IMPLIED", _wrap_XML_ATTRIBUTE_IMPLIED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ATTRIBUTE_FIXED", _wrap_XML_ATTRIBUTE_FIXED, 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", _wrap_XML_ELEMENT_CONTENT_PCDATA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_CONTENT_ELEMENT", _wrap_XML_ELEMENT_CONTENT_ELEMENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_CONTENT_SEQ", _wrap_XML_ELEMENT_CONTENT_SEQ, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_CONTENT_OR", _wrap_XML_ELEMENT_CONTENT_OR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_CONTENT_ONCE", _wrap_XML_ELEMENT_CONTENT_ONCE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_CONTENT_OPT", _wrap_XML_ELEMENT_CONTENT_OPT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_CONTENT_MULT", _wrap_XML_ELEMENT_CONTENT_MULT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_CONTENT_PLUS", _wrap_XML_ELEMENT_CONTENT_PLUS, 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", _wrap_XML_ELEMENT_TYPE_UNDEFINED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_TYPE_EMPTY", _wrap_XML_ELEMENT_TYPE_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_TYPE_ANY", _wrap_XML_ELEMENT_TYPE_ANY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_TYPE_MIXED", _wrap_XML_ELEMENT_TYPE_MIXED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ELEMENT_TYPE_ELEMENT", _wrap_XML_ELEMENT_TYPE_ELEMENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_EXP_EMPTY", _wrap_XML_EXP_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_EXP_FORBID", _wrap_XML_EXP_FORBID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_EXP_ATOM", _wrap_XML_EXP_ATOM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_EXP_SEQ", _wrap_XML_EXP_SEQ, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_EXP_OR", _wrap_XML_EXP_OR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_EXP_COUNT", _wrap_XML_EXP_COUNT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "forbiddenExp", _wrap_forbiddenExp_get, _wrap_forbiddenExp_set, context);
SWIGV8_AddStaticVariable(exports_obj, "emptyExp", _wrap_emptyExp_get, _wrap_emptyExp_set, 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, "_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", _wrap_XML_DOC_WELLFORMED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOC_NSVALID", _wrap_XML_DOC_NSVALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOC_OLD10", _wrap_XML_DOC_OLD10, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOC_DTDVALID", _wrap_XML_DOC_DTDVALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOC_XINCLUDE", _wrap_XML_DOC_XINCLUDE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOC_USERBUILT", _wrap_XML_DOC_USERBUILT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOC_INTERNAL", _wrap_XML_DOC_INTERNAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DOC_HTML", _wrap_XML_DOC_HTML, 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", _wrap_XML_ERR_NONE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_WARNING", _wrap_XML_ERR_WARNING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ERROR", _wrap_XML_ERR_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_FATAL", _wrap_XML_ERR_FATAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_NONE", _wrap_XML_FROM_NONE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_PARSER", _wrap_XML_FROM_PARSER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_TREE", _wrap_XML_FROM_TREE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_NAMESPACE", _wrap_XML_FROM_NAMESPACE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_DTD", _wrap_XML_FROM_DTD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_HTML", _wrap_XML_FROM_HTML, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_MEMORY", _wrap_XML_FROM_MEMORY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_OUTPUT", _wrap_XML_FROM_OUTPUT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_IO", _wrap_XML_FROM_IO, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_FTP", _wrap_XML_FROM_FTP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_HTTP", _wrap_XML_FROM_HTTP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_XINCLUDE", _wrap_XML_FROM_XINCLUDE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_XPATH", _wrap_XML_FROM_XPATH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_XPOINTER", _wrap_XML_FROM_XPOINTER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_REGEXP", _wrap_XML_FROM_REGEXP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_DATATYPE", _wrap_XML_FROM_DATATYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_SCHEMASP", _wrap_XML_FROM_SCHEMASP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_SCHEMASV", _wrap_XML_FROM_SCHEMASV, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_RELAXNGP", _wrap_XML_FROM_RELAXNGP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_RELAXNGV", _wrap_XML_FROM_RELAXNGV, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_CATALOG", _wrap_XML_FROM_CATALOG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_C14N", _wrap_XML_FROM_C14N, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_XSLT", _wrap_XML_FROM_XSLT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_VALID", _wrap_XML_FROM_VALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_CHECK", _wrap_XML_FROM_CHECK, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_WRITER", _wrap_XML_FROM_WRITER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_MODULE", _wrap_XML_FROM_MODULE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_I18N", _wrap_XML_FROM_I18N, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_SCHEMATRONV", _wrap_XML_FROM_SCHEMATRONV, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_BUFFER", _wrap_XML_FROM_BUFFER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FROM_URI", _wrap_XML_FROM_URI, 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", _wrap_XML_ERR_OK, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_INTERNAL_ERROR", _wrap_XML_ERR_INTERNAL_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NO_MEMORY", _wrap_XML_ERR_NO_MEMORY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_DOCUMENT_START", _wrap_XML_ERR_DOCUMENT_START, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_DOCUMENT_EMPTY", _wrap_XML_ERR_DOCUMENT_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_DOCUMENT_END", _wrap_XML_ERR_DOCUMENT_END, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_INVALID_HEX_CHARREF", _wrap_XML_ERR_INVALID_HEX_CHARREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_INVALID_DEC_CHARREF", _wrap_XML_ERR_INVALID_DEC_CHARREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_INVALID_CHARREF", _wrap_XML_ERR_INVALID_CHARREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_INVALID_CHAR", _wrap_XML_ERR_INVALID_CHAR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CHARREF_AT_EOF", _wrap_XML_ERR_CHARREF_AT_EOF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CHARREF_IN_PROLOG", _wrap_XML_ERR_CHARREF_IN_PROLOG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CHARREF_IN_EPILOG", _wrap_XML_ERR_CHARREF_IN_EPILOG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CHARREF_IN_DTD", _wrap_XML_ERR_CHARREF_IN_DTD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITYREF_AT_EOF", _wrap_XML_ERR_ENTITYREF_AT_EOF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITYREF_IN_PROLOG", _wrap_XML_ERR_ENTITYREF_IN_PROLOG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITYREF_IN_EPILOG", _wrap_XML_ERR_ENTITYREF_IN_EPILOG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITYREF_IN_DTD", _wrap_XML_ERR_ENTITYREF_IN_DTD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PEREF_AT_EOF", _wrap_XML_ERR_PEREF_AT_EOF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PEREF_IN_PROLOG", _wrap_XML_ERR_PEREF_IN_PROLOG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PEREF_IN_EPILOG", _wrap_XML_ERR_PEREF_IN_EPILOG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PEREF_IN_INT_SUBSET", _wrap_XML_ERR_PEREF_IN_INT_SUBSET, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITYREF_NO_NAME", _wrap_XML_ERR_ENTITYREF_NO_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITYREF_SEMICOL_MISSING", _wrap_XML_ERR_ENTITYREF_SEMICOL_MISSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PEREF_NO_NAME", _wrap_XML_ERR_PEREF_NO_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PEREF_SEMICOL_MISSING", _wrap_XML_ERR_PEREF_SEMICOL_MISSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_UNDECLARED_ENTITY", _wrap_XML_ERR_UNDECLARED_ENTITY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_UNDECLARED_ENTITY", _wrap_XML_WAR_UNDECLARED_ENTITY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_UNPARSED_ENTITY", _wrap_XML_ERR_UNPARSED_ENTITY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_IS_EXTERNAL", _wrap_XML_ERR_ENTITY_IS_EXTERNAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_IS_PARAMETER", _wrap_XML_ERR_ENTITY_IS_PARAMETER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_UNKNOWN_ENCODING", _wrap_XML_ERR_UNKNOWN_ENCODING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_UNSUPPORTED_ENCODING", _wrap_XML_ERR_UNSUPPORTED_ENCODING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_STRING_NOT_STARTED", _wrap_XML_ERR_STRING_NOT_STARTED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_STRING_NOT_CLOSED", _wrap_XML_ERR_STRING_NOT_CLOSED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NS_DECL_ERROR", _wrap_XML_ERR_NS_DECL_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_NOT_STARTED", _wrap_XML_ERR_ENTITY_NOT_STARTED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_NOT_FINISHED", _wrap_XML_ERR_ENTITY_NOT_FINISHED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_LT_IN_ATTRIBUTE", _wrap_XML_ERR_LT_IN_ATTRIBUTE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ATTRIBUTE_NOT_STARTED", _wrap_XML_ERR_ATTRIBUTE_NOT_STARTED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ATTRIBUTE_NOT_FINISHED", _wrap_XML_ERR_ATTRIBUTE_NOT_FINISHED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ATTRIBUTE_WITHOUT_VALUE", _wrap_XML_ERR_ATTRIBUTE_WITHOUT_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ATTRIBUTE_REDEFINED", _wrap_XML_ERR_ATTRIBUTE_REDEFINED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_LITERAL_NOT_STARTED", _wrap_XML_ERR_LITERAL_NOT_STARTED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_LITERAL_NOT_FINISHED", _wrap_XML_ERR_LITERAL_NOT_FINISHED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_COMMENT_NOT_FINISHED", _wrap_XML_ERR_COMMENT_NOT_FINISHED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PI_NOT_STARTED", _wrap_XML_ERR_PI_NOT_STARTED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PI_NOT_FINISHED", _wrap_XML_ERR_PI_NOT_FINISHED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NOTATION_NOT_STARTED", _wrap_XML_ERR_NOTATION_NOT_STARTED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NOTATION_NOT_FINISHED", _wrap_XML_ERR_NOTATION_NOT_FINISHED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ATTLIST_NOT_STARTED", _wrap_XML_ERR_ATTLIST_NOT_STARTED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ATTLIST_NOT_FINISHED", _wrap_XML_ERR_ATTLIST_NOT_FINISHED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_MIXED_NOT_STARTED", _wrap_XML_ERR_MIXED_NOT_STARTED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_MIXED_NOT_FINISHED", _wrap_XML_ERR_MIXED_NOT_FINISHED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ELEMCONTENT_NOT_STARTED", _wrap_XML_ERR_ELEMCONTENT_NOT_STARTED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ELEMCONTENT_NOT_FINISHED", _wrap_XML_ERR_ELEMCONTENT_NOT_FINISHED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_XMLDECL_NOT_STARTED", _wrap_XML_ERR_XMLDECL_NOT_STARTED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_XMLDECL_NOT_FINISHED", _wrap_XML_ERR_XMLDECL_NOT_FINISHED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CONDSEC_NOT_STARTED", _wrap_XML_ERR_CONDSEC_NOT_STARTED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CONDSEC_NOT_FINISHED", _wrap_XML_ERR_CONDSEC_NOT_FINISHED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_EXT_SUBSET_NOT_FINISHED", _wrap_XML_ERR_EXT_SUBSET_NOT_FINISHED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_DOCTYPE_NOT_FINISHED", _wrap_XML_ERR_DOCTYPE_NOT_FINISHED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_MISPLACED_CDATA_END", _wrap_XML_ERR_MISPLACED_CDATA_END, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CDATA_NOT_FINISHED", _wrap_XML_ERR_CDATA_NOT_FINISHED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_RESERVED_XML_NAME", _wrap_XML_ERR_RESERVED_XML_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_SPACE_REQUIRED", _wrap_XML_ERR_SPACE_REQUIRED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_SEPARATOR_REQUIRED", _wrap_XML_ERR_SEPARATOR_REQUIRED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NMTOKEN_REQUIRED", _wrap_XML_ERR_NMTOKEN_REQUIRED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NAME_REQUIRED", _wrap_XML_ERR_NAME_REQUIRED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PCDATA_REQUIRED", _wrap_XML_ERR_PCDATA_REQUIRED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_URI_REQUIRED", _wrap_XML_ERR_URI_REQUIRED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_PUBID_REQUIRED", _wrap_XML_ERR_PUBID_REQUIRED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_LT_REQUIRED", _wrap_XML_ERR_LT_REQUIRED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_GT_REQUIRED", _wrap_XML_ERR_GT_REQUIRED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_LTSLASH_REQUIRED", _wrap_XML_ERR_LTSLASH_REQUIRED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_EQUAL_REQUIRED", _wrap_XML_ERR_EQUAL_REQUIRED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_TAG_NAME_MISMATCH", _wrap_XML_ERR_TAG_NAME_MISMATCH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_TAG_NOT_FINISHED", _wrap_XML_ERR_TAG_NOT_FINISHED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_STANDALONE_VALUE", _wrap_XML_ERR_STANDALONE_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENCODING_NAME", _wrap_XML_ERR_ENCODING_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_HYPHEN_IN_COMMENT", _wrap_XML_ERR_HYPHEN_IN_COMMENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_INVALID_ENCODING", _wrap_XML_ERR_INVALID_ENCODING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_EXT_ENTITY_STANDALONE", _wrap_XML_ERR_EXT_ENTITY_STANDALONE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CONDSEC_INVALID", _wrap_XML_ERR_CONDSEC_INVALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_VALUE_REQUIRED", _wrap_XML_ERR_VALUE_REQUIRED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NOT_WELL_BALANCED", _wrap_XML_ERR_NOT_WELL_BALANCED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_EXTRA_CONTENT", _wrap_XML_ERR_EXTRA_CONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_CHAR_ERROR", _wrap_XML_ERR_ENTITY_CHAR_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_PE_INTERNAL", _wrap_XML_ERR_ENTITY_PE_INTERNAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_LOOP", _wrap_XML_ERR_ENTITY_LOOP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_BOUNDARY", _wrap_XML_ERR_ENTITY_BOUNDARY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_INVALID_URI", _wrap_XML_ERR_INVALID_URI, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_URI_FRAGMENT", _wrap_XML_ERR_URI_FRAGMENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_CATALOG_PI", _wrap_XML_WAR_CATALOG_PI, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NO_DTD", _wrap_XML_ERR_NO_DTD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_CONDSEC_INVALID_KEYWORD", _wrap_XML_ERR_CONDSEC_INVALID_KEYWORD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_VERSION_MISSING", _wrap_XML_ERR_VERSION_MISSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_UNKNOWN_VERSION", _wrap_XML_WAR_UNKNOWN_VERSION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_LANG_VALUE", _wrap_XML_WAR_LANG_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_NS_URI", _wrap_XML_WAR_NS_URI, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_NS_URI_RELATIVE", _wrap_XML_WAR_NS_URI_RELATIVE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_MISSING_ENCODING", _wrap_XML_ERR_MISSING_ENCODING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_SPACE_VALUE", _wrap_XML_WAR_SPACE_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NOT_STANDALONE", _wrap_XML_ERR_NOT_STANDALONE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_ENTITY_PROCESSING", _wrap_XML_ERR_ENTITY_PROCESSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NOTATION_PROCESSING", _wrap_XML_ERR_NOTATION_PROCESSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_NS_COLUMN", _wrap_XML_WAR_NS_COLUMN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WAR_ENTITY_REDEFINED", _wrap_XML_WAR_ENTITY_REDEFINED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_UNKNOWN_VERSION", _wrap_XML_ERR_UNKNOWN_VERSION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_VERSION_MISMATCH", _wrap_XML_ERR_VERSION_MISMATCH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_NAME_TOO_LONG", _wrap_XML_ERR_NAME_TOO_LONG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_ERR_USER_STOP", _wrap_XML_ERR_USER_STOP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_NS_ERR_XML_NAMESPACE", _wrap_XML_NS_ERR_XML_NAMESPACE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_NS_ERR_UNDEFINED_NAMESPACE", _wrap_XML_NS_ERR_UNDEFINED_NAMESPACE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_NS_ERR_QNAME", _wrap_XML_NS_ERR_QNAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_NS_ERR_ATTRIBUTE_REDEFINED", _wrap_XML_NS_ERR_ATTRIBUTE_REDEFINED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_NS_ERR_EMPTY", _wrap_XML_NS_ERR_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_NS_ERR_COLON", _wrap_XML_NS_ERR_COLON, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ATTRIBUTE_DEFAULT", _wrap_XML_DTD_ATTRIBUTE_DEFAULT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ATTRIBUTE_REDEFINED", _wrap_XML_DTD_ATTRIBUTE_REDEFINED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ATTRIBUTE_VALUE", _wrap_XML_DTD_ATTRIBUTE_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_CONTENT_ERROR", _wrap_XML_DTD_CONTENT_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_CONTENT_MODEL", _wrap_XML_DTD_CONTENT_MODEL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_CONTENT_NOT_DETERMINIST", _wrap_XML_DTD_CONTENT_NOT_DETERMINIST, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_DIFFERENT_PREFIX", _wrap_XML_DTD_DIFFERENT_PREFIX, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ELEM_DEFAULT_NAMESPACE", _wrap_XML_DTD_ELEM_DEFAULT_NAMESPACE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ELEM_NAMESPACE", _wrap_XML_DTD_ELEM_NAMESPACE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ELEM_REDEFINED", _wrap_XML_DTD_ELEM_REDEFINED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_EMPTY_NOTATION", _wrap_XML_DTD_EMPTY_NOTATION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ENTITY_TYPE", _wrap_XML_DTD_ENTITY_TYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ID_FIXED", _wrap_XML_DTD_ID_FIXED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ID_REDEFINED", _wrap_XML_DTD_ID_REDEFINED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ID_SUBSET", _wrap_XML_DTD_ID_SUBSET, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_INVALID_CHILD", _wrap_XML_DTD_INVALID_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_INVALID_DEFAULT", _wrap_XML_DTD_INVALID_DEFAULT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_LOAD_ERROR", _wrap_XML_DTD_LOAD_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_MISSING_ATTRIBUTE", _wrap_XML_DTD_MISSING_ATTRIBUTE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_MIXED_CORRUPT", _wrap_XML_DTD_MIXED_CORRUPT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_MULTIPLE_ID", _wrap_XML_DTD_MULTIPLE_ID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NO_DOC", _wrap_XML_DTD_NO_DOC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NO_DTD", _wrap_XML_DTD_NO_DTD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NO_ELEM_NAME", _wrap_XML_DTD_NO_ELEM_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NO_PREFIX", _wrap_XML_DTD_NO_PREFIX, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NO_ROOT", _wrap_XML_DTD_NO_ROOT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NOTATION_REDEFINED", _wrap_XML_DTD_NOTATION_REDEFINED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NOTATION_VALUE", _wrap_XML_DTD_NOTATION_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NOT_EMPTY", _wrap_XML_DTD_NOT_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NOT_PCDATA", _wrap_XML_DTD_NOT_PCDATA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_NOT_STANDALONE", _wrap_XML_DTD_NOT_STANDALONE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_ROOT_NAME", _wrap_XML_DTD_ROOT_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_STANDALONE_WHITE_SPACE", _wrap_XML_DTD_STANDALONE_WHITE_SPACE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_UNKNOWN_ATTRIBUTE", _wrap_XML_DTD_UNKNOWN_ATTRIBUTE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_UNKNOWN_ELEM", _wrap_XML_DTD_UNKNOWN_ELEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_UNKNOWN_ENTITY", _wrap_XML_DTD_UNKNOWN_ENTITY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_UNKNOWN_ID", _wrap_XML_DTD_UNKNOWN_ID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_UNKNOWN_NOTATION", _wrap_XML_DTD_UNKNOWN_NOTATION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_STANDALONE_DEFAULTED", _wrap_XML_DTD_STANDALONE_DEFAULTED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_XMLID_VALUE", _wrap_XML_DTD_XMLID_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_XMLID_TYPE", _wrap_XML_DTD_XMLID_TYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DTD_DUP_TOKEN", _wrap_XML_DTD_DUP_TOKEN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_HTML_STRUCURE_ERROR", _wrap_XML_HTML_STRUCURE_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_HTML_UNKNOWN_TAG", _wrap_XML_HTML_UNKNOWN_TAG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ANYNAME_ATTR_ANCESTOR", _wrap_XML_RNGP_ANYNAME_ATTR_ANCESTOR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ATTR_CONFLICT", _wrap_XML_RNGP_ATTR_CONFLICT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ATTRIBUTE_CHILDREN", _wrap_XML_RNGP_ATTRIBUTE_CHILDREN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ATTRIBUTE_CONTENT", _wrap_XML_RNGP_ATTRIBUTE_CONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ATTRIBUTE_EMPTY", _wrap_XML_RNGP_ATTRIBUTE_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ATTRIBUTE_NOOP", _wrap_XML_RNGP_ATTRIBUTE_NOOP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_CHOICE_CONTENT", _wrap_XML_RNGP_CHOICE_CONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_CHOICE_EMPTY", _wrap_XML_RNGP_CHOICE_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_CREATE_FAILURE", _wrap_XML_RNGP_CREATE_FAILURE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_DATA_CONTENT", _wrap_XML_RNGP_DATA_CONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_DEF_CHOICE_AND_INTERLEAVE", _wrap_XML_RNGP_DEF_CHOICE_AND_INTERLEAVE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_DEFINE_CREATE_FAILED", _wrap_XML_RNGP_DEFINE_CREATE_FAILED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_DEFINE_EMPTY", _wrap_XML_RNGP_DEFINE_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_DEFINE_MISSING", _wrap_XML_RNGP_DEFINE_MISSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_DEFINE_NAME_MISSING", _wrap_XML_RNGP_DEFINE_NAME_MISSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ELEM_CONTENT_EMPTY", _wrap_XML_RNGP_ELEM_CONTENT_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ELEM_CONTENT_ERROR", _wrap_XML_RNGP_ELEM_CONTENT_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ELEMENT_EMPTY", _wrap_XML_RNGP_ELEMENT_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ELEMENT_CONTENT", _wrap_XML_RNGP_ELEMENT_CONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ELEMENT_NAME", _wrap_XML_RNGP_ELEMENT_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ELEMENT_NO_CONTENT", _wrap_XML_RNGP_ELEMENT_NO_CONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ELEM_TEXT_CONFLICT", _wrap_XML_RNGP_ELEM_TEXT_CONFLICT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EMPTY", _wrap_XML_RNGP_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EMPTY_CONSTRUCT", _wrap_XML_RNGP_EMPTY_CONSTRUCT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EMPTY_CONTENT", _wrap_XML_RNGP_EMPTY_CONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EMPTY_NOT_EMPTY", _wrap_XML_RNGP_EMPTY_NOT_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_ERROR_TYPE_LIB", _wrap_XML_RNGP_ERROR_TYPE_LIB, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EXCEPT_EMPTY", _wrap_XML_RNGP_EXCEPT_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EXCEPT_MISSING", _wrap_XML_RNGP_EXCEPT_MISSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EXCEPT_MULTIPLE", _wrap_XML_RNGP_EXCEPT_MULTIPLE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EXCEPT_NO_CONTENT", _wrap_XML_RNGP_EXCEPT_NO_CONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EXTERNALREF_EMTPY", _wrap_XML_RNGP_EXTERNALREF_EMTPY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EXTERNAL_REF_FAILURE", _wrap_XML_RNGP_EXTERNAL_REF_FAILURE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_EXTERNALREF_RECURSE", _wrap_XML_RNGP_EXTERNALREF_RECURSE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_FORBIDDEN_ATTRIBUTE", _wrap_XML_RNGP_FORBIDDEN_ATTRIBUTE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_FOREIGN_ELEMENT", _wrap_XML_RNGP_FOREIGN_ELEMENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_GRAMMAR_CONTENT", _wrap_XML_RNGP_GRAMMAR_CONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_GRAMMAR_EMPTY", _wrap_XML_RNGP_GRAMMAR_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_GRAMMAR_MISSING", _wrap_XML_RNGP_GRAMMAR_MISSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_GRAMMAR_NO_START", _wrap_XML_RNGP_GRAMMAR_NO_START, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_GROUP_ATTR_CONFLICT", _wrap_XML_RNGP_GROUP_ATTR_CONFLICT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_HREF_ERROR", _wrap_XML_RNGP_HREF_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INCLUDE_EMPTY", _wrap_XML_RNGP_INCLUDE_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INCLUDE_FAILURE", _wrap_XML_RNGP_INCLUDE_FAILURE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INCLUDE_RECURSE", _wrap_XML_RNGP_INCLUDE_RECURSE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INTERLEAVE_ADD", _wrap_XML_RNGP_INTERLEAVE_ADD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INTERLEAVE_CREATE_FAILED", _wrap_XML_RNGP_INTERLEAVE_CREATE_FAILED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INTERLEAVE_EMPTY", _wrap_XML_RNGP_INTERLEAVE_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INTERLEAVE_NO_CONTENT", _wrap_XML_RNGP_INTERLEAVE_NO_CONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INVALID_DEFINE_NAME", _wrap_XML_RNGP_INVALID_DEFINE_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INVALID_URI", _wrap_XML_RNGP_INVALID_URI, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_INVALID_VALUE", _wrap_XML_RNGP_INVALID_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_MISSING_HREF", _wrap_XML_RNGP_MISSING_HREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_NAME_MISSING", _wrap_XML_RNGP_NAME_MISSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_NEED_COMBINE", _wrap_XML_RNGP_NEED_COMBINE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_NOTALLOWED_NOT_EMPTY", _wrap_XML_RNGP_NOTALLOWED_NOT_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_NSNAME_ATTR_ANCESTOR", _wrap_XML_RNGP_NSNAME_ATTR_ANCESTOR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_NSNAME_NO_NS", _wrap_XML_RNGP_NSNAME_NO_NS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PARAM_FORBIDDEN", _wrap_XML_RNGP_PARAM_FORBIDDEN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PARAM_NAME_MISSING", _wrap_XML_RNGP_PARAM_NAME_MISSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PARENTREF_CREATE_FAILED", _wrap_XML_RNGP_PARENTREF_CREATE_FAILED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PARENTREF_NAME_INVALID", _wrap_XML_RNGP_PARENTREF_NAME_INVALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PARENTREF_NO_NAME", _wrap_XML_RNGP_PARENTREF_NO_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PARENTREF_NO_PARENT", _wrap_XML_RNGP_PARENTREF_NO_PARENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PARENTREF_NOT_EMPTY", _wrap_XML_RNGP_PARENTREF_NOT_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PARSE_ERROR", _wrap_XML_RNGP_PARSE_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME", _wrap_XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_ATTR_ATTR", _wrap_XML_RNGP_PAT_ATTR_ATTR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_ATTR_ELEM", _wrap_XML_RNGP_PAT_ATTR_ELEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_ATTR", _wrap_XML_RNGP_PAT_DATA_EXCEPT_ATTR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_ELEM", _wrap_XML_RNGP_PAT_DATA_EXCEPT_ELEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_EMPTY", _wrap_XML_RNGP_PAT_DATA_EXCEPT_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_GROUP", _wrap_XML_RNGP_PAT_DATA_EXCEPT_GROUP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE", _wrap_XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_LIST", _wrap_XML_RNGP_PAT_DATA_EXCEPT_LIST, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_ONEMORE", _wrap_XML_RNGP_PAT_DATA_EXCEPT_ONEMORE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_REF", _wrap_XML_RNGP_PAT_DATA_EXCEPT_REF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_DATA_EXCEPT_TEXT", _wrap_XML_RNGP_PAT_DATA_EXCEPT_TEXT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_LIST_ATTR", _wrap_XML_RNGP_PAT_LIST_ATTR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_LIST_ELEM", _wrap_XML_RNGP_PAT_LIST_ELEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_LIST_INTERLEAVE", _wrap_XML_RNGP_PAT_LIST_INTERLEAVE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_LIST_LIST", _wrap_XML_RNGP_PAT_LIST_LIST, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_LIST_REF", _wrap_XML_RNGP_PAT_LIST_REF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_LIST_TEXT", _wrap_XML_RNGP_PAT_LIST_TEXT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME", _wrap_XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME", _wrap_XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_ONEMORE_GROUP_ATTR", _wrap_XML_RNGP_PAT_ONEMORE_GROUP_ATTR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR", _wrap_XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_ATTR", _wrap_XML_RNGP_PAT_START_ATTR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_DATA", _wrap_XML_RNGP_PAT_START_DATA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_EMPTY", _wrap_XML_RNGP_PAT_START_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_GROUP", _wrap_XML_RNGP_PAT_START_GROUP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_INTERLEAVE", _wrap_XML_RNGP_PAT_START_INTERLEAVE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_LIST", _wrap_XML_RNGP_PAT_START_LIST, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_ONEMORE", _wrap_XML_RNGP_PAT_START_ONEMORE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_TEXT", _wrap_XML_RNGP_PAT_START_TEXT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PAT_START_VALUE", _wrap_XML_RNGP_PAT_START_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_PREFIX_UNDEFINED", _wrap_XML_RNGP_PREFIX_UNDEFINED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_REF_CREATE_FAILED", _wrap_XML_RNGP_REF_CREATE_FAILED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_REF_CYCLE", _wrap_XML_RNGP_REF_CYCLE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_REF_NAME_INVALID", _wrap_XML_RNGP_REF_NAME_INVALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_REF_NO_DEF", _wrap_XML_RNGP_REF_NO_DEF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_REF_NO_NAME", _wrap_XML_RNGP_REF_NO_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_REF_NOT_EMPTY", _wrap_XML_RNGP_REF_NOT_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_START_CHOICE_AND_INTERLEAVE", _wrap_XML_RNGP_START_CHOICE_AND_INTERLEAVE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_START_CONTENT", _wrap_XML_RNGP_START_CONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_START_EMPTY", _wrap_XML_RNGP_START_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_START_MISSING", _wrap_XML_RNGP_START_MISSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_TEXT_EXPECTED", _wrap_XML_RNGP_TEXT_EXPECTED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_TEXT_HAS_CHILD", _wrap_XML_RNGP_TEXT_HAS_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_TYPE_MISSING", _wrap_XML_RNGP_TYPE_MISSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_TYPE_NOT_FOUND", _wrap_XML_RNGP_TYPE_NOT_FOUND, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_TYPE_VALUE", _wrap_XML_RNGP_TYPE_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_UNKNOWN_ATTRIBUTE", _wrap_XML_RNGP_UNKNOWN_ATTRIBUTE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_UNKNOWN_COMBINE", _wrap_XML_RNGP_UNKNOWN_COMBINE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_UNKNOWN_CONSTRUCT", _wrap_XML_RNGP_UNKNOWN_CONSTRUCT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_UNKNOWN_TYPE_LIB", _wrap_XML_RNGP_UNKNOWN_TYPE_LIB, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_URI_FRAGMENT", _wrap_XML_RNGP_URI_FRAGMENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_URI_NOT_ABSOLUTE", _wrap_XML_RNGP_URI_NOT_ABSOLUTE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_VALUE_EMPTY", _wrap_XML_RNGP_VALUE_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_VALUE_NO_CONTENT", _wrap_XML_RNGP_VALUE_NO_CONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_XMLNS_NAME", _wrap_XML_RNGP_XMLNS_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RNGP_XML_NS", _wrap_XML_RNGP_XML_NS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_EXPRESSION_OK", _wrap_XML_XPATH_EXPRESSION_OK, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_NUMBER_ERROR", _wrap_XML_XPATH_NUMBER_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_UNFINISHED_LITERAL_ERROR", _wrap_XML_XPATH_UNFINISHED_LITERAL_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_START_LITERAL_ERROR", _wrap_XML_XPATH_START_LITERAL_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_VARIABLE_REF_ERROR", _wrap_XML_XPATH_VARIABLE_REF_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_UNDEF_VARIABLE_ERROR", _wrap_XML_XPATH_UNDEF_VARIABLE_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_INVALID_PREDICATE_ERROR", _wrap_XML_XPATH_INVALID_PREDICATE_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_EXPR_ERROR", _wrap_XML_XPATH_EXPR_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_UNCLOSED_ERROR", _wrap_XML_XPATH_UNCLOSED_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_UNKNOWN_FUNC_ERROR", _wrap_XML_XPATH_UNKNOWN_FUNC_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_INVALID_OPERAND", _wrap_XML_XPATH_INVALID_OPERAND, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_INVALID_TYPE", _wrap_XML_XPATH_INVALID_TYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_INVALID_ARITY", _wrap_XML_XPATH_INVALID_ARITY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_INVALID_CTXT_SIZE", _wrap_XML_XPATH_INVALID_CTXT_SIZE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_INVALID_CTXT_POSITION", _wrap_XML_XPATH_INVALID_CTXT_POSITION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_MEMORY_ERROR", _wrap_XML_XPATH_MEMORY_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPTR_SYNTAX_ERROR", _wrap_XML_XPTR_SYNTAX_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPTR_RESOURCE_ERROR", _wrap_XML_XPTR_RESOURCE_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPTR_SUB_RESOURCE_ERROR", _wrap_XML_XPTR_SUB_RESOURCE_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_UNDEF_PREFIX_ERROR", _wrap_XML_XPATH_UNDEF_PREFIX_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_ENCODING_ERROR", _wrap_XML_XPATH_ENCODING_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_INVALID_CHAR_ERROR", _wrap_XML_XPATH_INVALID_CHAR_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_TREE_INVALID_HEX", _wrap_XML_TREE_INVALID_HEX, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_TREE_INVALID_DEC", _wrap_XML_TREE_INVALID_DEC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_TREE_UNTERMINATED_ENTITY", _wrap_XML_TREE_UNTERMINATED_ENTITY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_TREE_NOT_UTF8", _wrap_XML_TREE_NOT_UTF8, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_NOT_UTF8", _wrap_XML_SAVE_NOT_UTF8, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_CHAR_INVALID", _wrap_XML_SAVE_CHAR_INVALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_NO_DOCTYPE", _wrap_XML_SAVE_NO_DOCTYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_UNKNOWN_ENCODING", _wrap_XML_SAVE_UNKNOWN_ENCODING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_REGEXP_COMPILE_ERROR", _wrap_XML_REGEXP_COMPILE_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_UNKNOWN", _wrap_XML_IO_UNKNOWN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EACCES", _wrap_XML_IO_EACCES, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EAGAIN", _wrap_XML_IO_EAGAIN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EBADF", _wrap_XML_IO_EBADF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EBADMSG", _wrap_XML_IO_EBADMSG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EBUSY", _wrap_XML_IO_EBUSY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ECANCELED", _wrap_XML_IO_ECANCELED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ECHILD", _wrap_XML_IO_ECHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EDEADLK", _wrap_XML_IO_EDEADLK, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EDOM", _wrap_XML_IO_EDOM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EEXIST", _wrap_XML_IO_EEXIST, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EFAULT", _wrap_XML_IO_EFAULT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EFBIG", _wrap_XML_IO_EFBIG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EINPROGRESS", _wrap_XML_IO_EINPROGRESS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EINTR", _wrap_XML_IO_EINTR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EINVAL", _wrap_XML_IO_EINVAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EIO", _wrap_XML_IO_EIO, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EISDIR", _wrap_XML_IO_EISDIR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EMFILE", _wrap_XML_IO_EMFILE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EMLINK", _wrap_XML_IO_EMLINK, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EMSGSIZE", _wrap_XML_IO_EMSGSIZE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENAMETOOLONG", _wrap_XML_IO_ENAMETOOLONG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENFILE", _wrap_XML_IO_ENFILE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENODEV", _wrap_XML_IO_ENODEV, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOENT", _wrap_XML_IO_ENOENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOEXEC", _wrap_XML_IO_ENOEXEC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOLCK", _wrap_XML_IO_ENOLCK, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOMEM", _wrap_XML_IO_ENOMEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOSPC", _wrap_XML_IO_ENOSPC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOSYS", _wrap_XML_IO_ENOSYS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOTDIR", _wrap_XML_IO_ENOTDIR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOTEMPTY", _wrap_XML_IO_ENOTEMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOTSUP", _wrap_XML_IO_ENOTSUP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOTTY", _wrap_XML_IO_ENOTTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENXIO", _wrap_XML_IO_ENXIO, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EPERM", _wrap_XML_IO_EPERM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EPIPE", _wrap_XML_IO_EPIPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ERANGE", _wrap_XML_IO_ERANGE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EROFS", _wrap_XML_IO_EROFS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ESPIPE", _wrap_XML_IO_ESPIPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ESRCH", _wrap_XML_IO_ESRCH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ETIMEDOUT", _wrap_XML_IO_ETIMEDOUT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EXDEV", _wrap_XML_IO_EXDEV, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_NETWORK_ATTEMPT", _wrap_XML_IO_NETWORK_ATTEMPT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENCODER", _wrap_XML_IO_ENCODER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_FLUSH", _wrap_XML_IO_FLUSH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_WRITE", _wrap_XML_IO_WRITE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_NO_INPUT", _wrap_XML_IO_NO_INPUT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_BUFFER_FULL", _wrap_XML_IO_BUFFER_FULL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_LOAD_ERROR", _wrap_XML_IO_LOAD_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENOTSOCK", _wrap_XML_IO_ENOTSOCK, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EISCONN", _wrap_XML_IO_EISCONN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ECONNREFUSED", _wrap_XML_IO_ECONNREFUSED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_ENETUNREACH", _wrap_XML_IO_ENETUNREACH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EADDRINUSE", _wrap_XML_IO_EADDRINUSE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EALREADY", _wrap_XML_IO_EALREADY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_IO_EAFNOSUPPORT", _wrap_XML_IO_EAFNOSUPPORT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_RECURSION", _wrap_XML_XINCLUDE_RECURSION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_PARSE_VALUE", _wrap_XML_XINCLUDE_PARSE_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_ENTITY_DEF_MISMATCH", _wrap_XML_XINCLUDE_ENTITY_DEF_MISMATCH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_NO_HREF", _wrap_XML_XINCLUDE_NO_HREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_NO_FALLBACK", _wrap_XML_XINCLUDE_NO_FALLBACK, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_HREF_URI", _wrap_XML_XINCLUDE_HREF_URI, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_TEXT_FRAGMENT", _wrap_XML_XINCLUDE_TEXT_FRAGMENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_TEXT_DOCUMENT", _wrap_XML_XINCLUDE_TEXT_DOCUMENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_INVALID_CHAR", _wrap_XML_XINCLUDE_INVALID_CHAR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_BUILD_FAILED", _wrap_XML_XINCLUDE_BUILD_FAILED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_UNKNOWN_ENCODING", _wrap_XML_XINCLUDE_UNKNOWN_ENCODING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_MULTIPLE_ROOT", _wrap_XML_XINCLUDE_MULTIPLE_ROOT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_XPTR_FAILED", _wrap_XML_XINCLUDE_XPTR_FAILED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_XPTR_RESULT", _wrap_XML_XINCLUDE_XPTR_RESULT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_INCLUDE_IN_INCLUDE", _wrap_XML_XINCLUDE_INCLUDE_IN_INCLUDE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_FALLBACKS_IN_INCLUDE", _wrap_XML_XINCLUDE_FALLBACKS_IN_INCLUDE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE", _wrap_XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_DEPRECATED_NS", _wrap_XML_XINCLUDE_DEPRECATED_NS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XINCLUDE_FRAGMENT_ID", _wrap_XML_XINCLUDE_FRAGMENT_ID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATALOG_MISSING_ATTR", _wrap_XML_CATALOG_MISSING_ATTR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATALOG_ENTRY_BROKEN", _wrap_XML_CATALOG_ENTRY_BROKEN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATALOG_PREFER_VALUE", _wrap_XML_CATALOG_PREFER_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATALOG_NOT_CATALOG", _wrap_XML_CATALOG_NOT_CATALOG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATALOG_RECURSION", _wrap_XML_CATALOG_RECURSION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_PREFIX_UNDEFINED", _wrap_XML_SCHEMAP_PREFIX_UNDEFINED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ATTRFORMDEFAULT_VALUE", _wrap_XML_SCHEMAP_ATTRFORMDEFAULT_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ATTRGRP_NONAME_NOREF", _wrap_XML_SCHEMAP_ATTRGRP_NONAME_NOREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ATTR_NONAME_NOREF", _wrap_XML_SCHEMAP_ATTR_NONAME_NOREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF", _wrap_XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ELEMFORMDEFAULT_VALUE", _wrap_XML_SCHEMAP_ELEMFORMDEFAULT_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ELEM_NONAME_NOREF", _wrap_XML_SCHEMAP_ELEM_NONAME_NOREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_EXTENSION_NO_BASE", _wrap_XML_SCHEMAP_EXTENSION_NO_BASE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_FACET_NO_VALUE", _wrap_XML_SCHEMAP_FACET_NO_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_FAILED_BUILD_IMPORT", _wrap_XML_SCHEMAP_FAILED_BUILD_IMPORT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_GROUP_NONAME_NOREF", _wrap_XML_SCHEMAP_GROUP_NONAME_NOREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI", _wrap_XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_IMPORT_REDEFINE_NSNAME", _wrap_XML_SCHEMAP_IMPORT_REDEFINE_NSNAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI", _wrap_XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_BOOLEAN", _wrap_XML_SCHEMAP_INVALID_BOOLEAN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_ENUM", _wrap_XML_SCHEMAP_INVALID_ENUM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_FACET", _wrap_XML_SCHEMAP_INVALID_FACET, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_FACET_VALUE", _wrap_XML_SCHEMAP_INVALID_FACET_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_MAXOCCURS", _wrap_XML_SCHEMAP_INVALID_MAXOCCURS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_MINOCCURS", _wrap_XML_SCHEMAP_INVALID_MINOCCURS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_REF_AND_SUBTYPE", _wrap_XML_SCHEMAP_INVALID_REF_AND_SUBTYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_WHITE_SPACE", _wrap_XML_SCHEMAP_INVALID_WHITE_SPACE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NOATTR_NOREF", _wrap_XML_SCHEMAP_NOATTR_NOREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NOTATION_NO_NAME", _wrap_XML_SCHEMAP_NOTATION_NO_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NOTYPE_NOREF", _wrap_XML_SCHEMAP_NOTYPE_NOREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REF_AND_SUBTYPE", _wrap_XML_SCHEMAP_REF_AND_SUBTYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_RESTRICTION_NONAME_NOREF", _wrap_XML_SCHEMAP_RESTRICTION_NONAME_NOREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SIMPLETYPE_NONAME", _wrap_XML_SCHEMAP_SIMPLETYPE_NONAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_TYPE_AND_SUBTYPE", _wrap_XML_SCHEMAP_TYPE_AND_SUBTYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_ALL_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_ALL_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_ATTR_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_ATTR_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP", _wrap_XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_BASE_TYPE", _wrap_XML_SCHEMAP_UNKNOWN_BASE_TYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_CHOICE_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_CHOICE_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_ELEM_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_ELEM_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_FACET_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_FACET_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_FACET_TYPE", _wrap_XML_SCHEMAP_UNKNOWN_FACET_TYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_GROUP_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_GROUP_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_IMPORT_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_IMPORT_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_LIST_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_LIST_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_NOTATION_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_NOTATION_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_REF", _wrap_XML_SCHEMAP_UNKNOWN_REF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_TYPE", _wrap_XML_SCHEMAP_UNKNOWN_TYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_UNION_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_UNION_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ELEM_DEFAULT_FIXED", _wrap_XML_SCHEMAP_ELEM_DEFAULT_FIXED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REGEXP_INVALID", _wrap_XML_SCHEMAP_REGEXP_INVALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_FAILED_LOAD", _wrap_XML_SCHEMAP_FAILED_LOAD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NOTHING_TO_PARSE", _wrap_XML_SCHEMAP_NOTHING_TO_PARSE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NOROOT", _wrap_XML_SCHEMAP_NOROOT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REDEFINED_GROUP", _wrap_XML_SCHEMAP_REDEFINED_GROUP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REDEFINED_TYPE", _wrap_XML_SCHEMAP_REDEFINED_TYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REDEFINED_ELEMENT", _wrap_XML_SCHEMAP_REDEFINED_ELEMENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REDEFINED_ATTRGROUP", _wrap_XML_SCHEMAP_REDEFINED_ATTRGROUP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REDEFINED_ATTR", _wrap_XML_SCHEMAP_REDEFINED_ATTR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REDEFINED_NOTATION", _wrap_XML_SCHEMAP_REDEFINED_NOTATION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_FAILED_PARSE", _wrap_XML_SCHEMAP_FAILED_PARSE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_PREFIX", _wrap_XML_SCHEMAP_UNKNOWN_PREFIX, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DEF_AND_PREFIX", _wrap_XML_SCHEMAP_DEF_AND_PREFIX, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD", _wrap_XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI", _wrap_XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI", _wrap_XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NOT_SCHEMA", _wrap_XML_SCHEMAP_NOT_SCHEMA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNKNOWN_MEMBER_TYPE", _wrap_XML_SCHEMAP_UNKNOWN_MEMBER_TYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_ATTR_USE", _wrap_XML_SCHEMAP_INVALID_ATTR_USE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_RECURSIVE", _wrap_XML_SCHEMAP_RECURSIVE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE", _wrap_XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_ATTR_COMBINATION", _wrap_XML_SCHEMAP_INVALID_ATTR_COMBINATION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION", _wrap_XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD", _wrap_XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INVALID_ATTR_NAME", _wrap_XML_SCHEMAP_INVALID_ATTR_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_REF_AND_CONTENT", _wrap_XML_SCHEMAP_REF_AND_CONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_CT_PROPS_CORRECT_1", _wrap_XML_SCHEMAP_CT_PROPS_CORRECT_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_CT_PROPS_CORRECT_2", _wrap_XML_SCHEMAP_CT_PROPS_CORRECT_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_CT_PROPS_CORRECT_3", _wrap_XML_SCHEMAP_CT_PROPS_CORRECT_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_CT_PROPS_CORRECT_4", _wrap_XML_SCHEMAP_CT_PROPS_CORRECT_4, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_CT_PROPS_CORRECT_5", _wrap_XML_SCHEMAP_CT_PROPS_CORRECT_5, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1", _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1", _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2", _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2", _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3", _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER", _wrap_XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE", _wrap_XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_UNION_NOT_EXPRESSIBLE", _wrap_XML_SCHEMAP_UNION_NOT_EXPRESSIBLE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_IMPORT_3_1", _wrap_XML_SCHEMAP_SRC_IMPORT_3_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_IMPORT_3_2", _wrap_XML_SCHEMAP_SRC_IMPORT_3_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1", _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2", _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3", _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_CT_EXTENDS_1_3", _wrap_XML_SCHEMAP_COS_CT_EXTENDS_1_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_NOROOT", _wrap_XML_SCHEMAV_NOROOT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_UNDECLAREDELEM", _wrap_XML_SCHEMAV_UNDECLAREDELEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_NOTTOPLEVEL", _wrap_XML_SCHEMAV_NOTTOPLEVEL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_MISSING", _wrap_XML_SCHEMAV_MISSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_WRONGELEM", _wrap_XML_SCHEMAV_WRONGELEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_NOTYPE", _wrap_XML_SCHEMAV_NOTYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_NOROLLBACK", _wrap_XML_SCHEMAV_NOROLLBACK, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_ISABSTRACT", _wrap_XML_SCHEMAV_ISABSTRACT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_NOTEMPTY", _wrap_XML_SCHEMAV_NOTEMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_ELEMCONT", _wrap_XML_SCHEMAV_ELEMCONT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_HAVEDEFAULT", _wrap_XML_SCHEMAV_HAVEDEFAULT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_NOTNILLABLE", _wrap_XML_SCHEMAV_NOTNILLABLE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_EXTRACONTENT", _wrap_XML_SCHEMAV_EXTRACONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_INVALIDATTR", _wrap_XML_SCHEMAV_INVALIDATTR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_INVALIDELEM", _wrap_XML_SCHEMAV_INVALIDELEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_NOTDETERMINIST", _wrap_XML_SCHEMAV_NOTDETERMINIST, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CONSTRUCT", _wrap_XML_SCHEMAV_CONSTRUCT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_INTERNAL", _wrap_XML_SCHEMAV_INTERNAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_NOTSIMPLE", _wrap_XML_SCHEMAV_NOTSIMPLE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_ATTRUNKNOWN", _wrap_XML_SCHEMAV_ATTRUNKNOWN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_ATTRINVALID", _wrap_XML_SCHEMAV_ATTRINVALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_VALUE", _wrap_XML_SCHEMAV_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_FACET", _wrap_XML_SCHEMAV_FACET, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1", _wrap_XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2", _wrap_XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3", _wrap_XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_TYPE_3_1_1", _wrap_XML_SCHEMAV_CVC_TYPE_3_1_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_TYPE_3_1_2", _wrap_XML_SCHEMAV_CVC_TYPE_3_1_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_FACET_VALID", _wrap_XML_SCHEMAV_CVC_FACET_VALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_LENGTH_VALID", _wrap_XML_SCHEMAV_CVC_LENGTH_VALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_MINLENGTH_VALID", _wrap_XML_SCHEMAV_CVC_MINLENGTH_VALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_MAXLENGTH_VALID", _wrap_XML_SCHEMAV_CVC_MAXLENGTH_VALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_MININCLUSIVE_VALID", _wrap_XML_SCHEMAV_CVC_MININCLUSIVE_VALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID", _wrap_XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID", _wrap_XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID", _wrap_XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_TOTALDIGITS_VALID", _wrap_XML_SCHEMAV_CVC_TOTALDIGITS_VALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID", _wrap_XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_PATTERN_VALID", _wrap_XML_SCHEMAV_CVC_PATTERN_VALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ENUMERATION_VALID", _wrap_XML_SCHEMAV_CVC_ENUMERATION_VALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1", _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2", _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3", _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4", _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_1", _wrap_XML_SCHEMAV_CVC_ELT_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_2", _wrap_XML_SCHEMAV_CVC_ELT_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_3_1", _wrap_XML_SCHEMAV_CVC_ELT_3_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_3_2_1", _wrap_XML_SCHEMAV_CVC_ELT_3_2_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_3_2_2", _wrap_XML_SCHEMAV_CVC_ELT_3_2_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_4_1", _wrap_XML_SCHEMAV_CVC_ELT_4_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_4_2", _wrap_XML_SCHEMAV_CVC_ELT_4_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_4_3", _wrap_XML_SCHEMAV_CVC_ELT_4_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_5_1_1", _wrap_XML_SCHEMAV_CVC_ELT_5_1_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_5_1_2", _wrap_XML_SCHEMAV_CVC_ELT_5_1_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_5_2_1", _wrap_XML_SCHEMAV_CVC_ELT_5_2_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_5_2_2_1", _wrap_XML_SCHEMAV_CVC_ELT_5_2_2_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_5_2_2_2_1", _wrap_XML_SCHEMAV_CVC_ELT_5_2_2_2_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_5_2_2_2_2", _wrap_XML_SCHEMAV_CVC_ELT_5_2_2_2_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_6", _wrap_XML_SCHEMAV_CVC_ELT_6, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ELT_7", _wrap_XML_SCHEMAV_CVC_ELT_7, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ATTRIBUTE_1", _wrap_XML_SCHEMAV_CVC_ATTRIBUTE_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ATTRIBUTE_2", _wrap_XML_SCHEMAV_CVC_ATTRIBUTE_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ATTRIBUTE_3", _wrap_XML_SCHEMAV_CVC_ATTRIBUTE_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_ATTRIBUTE_4", _wrap_XML_SCHEMAV_CVC_ATTRIBUTE_4, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1", _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1", _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2", _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_4", _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_4, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1", _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2", _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_ELEMENT_CONTENT", _wrap_XML_SCHEMAV_ELEMENT_CONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING", _wrap_XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_COMPLEX_TYPE_1", _wrap_XML_SCHEMAV_CVC_COMPLEX_TYPE_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_AU", _wrap_XML_SCHEMAV_CVC_AU, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_TYPE_1", _wrap_XML_SCHEMAV_CVC_TYPE_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_TYPE_2", _wrap_XML_SCHEMAV_CVC_TYPE_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_IDC", _wrap_XML_SCHEMAV_CVC_IDC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_CVC_WILDCARD", _wrap_XML_SCHEMAV_CVC_WILDCARD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAV_MISC", _wrap_XML_SCHEMAV_MISC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPTR_UNKNOWN_SCHEME", _wrap_XML_XPTR_UNKNOWN_SCHEME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPTR_CHILDSEQ_START", _wrap_XML_XPTR_CHILDSEQ_START, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPTR_EVAL_FAILED", _wrap_XML_XPTR_EVAL_FAILED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPTR_EXTRA_OBJECTS", _wrap_XML_XPTR_EXTRA_OBJECTS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_C14N_CREATE_CTXT", _wrap_XML_C14N_CREATE_CTXT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_C14N_REQUIRES_UTF8", _wrap_XML_C14N_REQUIRES_UTF8, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_C14N_CREATE_STACK", _wrap_XML_C14N_CREATE_STACK, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_C14N_INVALID_NODE", _wrap_XML_C14N_INVALID_NODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_C14N_UNKNOW_NODE", _wrap_XML_C14N_UNKNOW_NODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_C14N_RELATIVE_NAMESPACE", _wrap_XML_C14N_RELATIVE_NAMESPACE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FTP_PASV_ANSWER", _wrap_XML_FTP_PASV_ANSWER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FTP_EPSV_ANSWER", _wrap_XML_FTP_EPSV_ANSWER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FTP_ACCNT", _wrap_XML_FTP_ACCNT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_FTP_URL_SYNTAX", _wrap_XML_FTP_URL_SYNTAX, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_HTTP_URL_SYNTAX", _wrap_XML_HTTP_URL_SYNTAX, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_HTTP_USE_IP", _wrap_XML_HTTP_USE_IP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_HTTP_UNKNOWN_HOST", _wrap_XML_HTTP_UNKNOWN_HOST, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_SIMPLE_TYPE_1", _wrap_XML_SCHEMAP_SRC_SIMPLE_TYPE_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_SIMPLE_TYPE_2", _wrap_XML_SCHEMAP_SRC_SIMPLE_TYPE_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_SIMPLE_TYPE_3", _wrap_XML_SCHEMAP_SRC_SIMPLE_TYPE_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_SIMPLE_TYPE_4", _wrap_XML_SCHEMAP_SRC_SIMPLE_TYPE_4, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_RESOLVE", _wrap_XML_SCHEMAP_SRC_RESOLVE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE", _wrap_XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE", _wrap_XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES", _wrap_XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ST_PROPS_CORRECT_1", _wrap_XML_SCHEMAP_ST_PROPS_CORRECT_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ST_PROPS_CORRECT_2", _wrap_XML_SCHEMAP_ST_PROPS_CORRECT_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_ST_PROPS_CORRECT_3", _wrap_XML_SCHEMAP_ST_PROPS_CORRECT_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_1_1", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_1_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_1_2", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_1_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_2_1", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_2_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_3_1", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_3_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5", _wrap_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_DERIVED_OK_2_1", _wrap_XML_SCHEMAP_COS_ST_DERIVED_OK_2_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ST_DERIVED_OK_2_2", _wrap_XML_SCHEMAP_COS_ST_DERIVED_OK_2_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED", _wrap_XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_S4S_ELEM_MISSING", _wrap_XML_SCHEMAP_S4S_ELEM_MISSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED", _wrap_XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_S4S_ATTR_MISSING", _wrap_XML_SCHEMAP_S4S_ATTR_MISSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_S4S_ATTR_INVALID_VALUE", _wrap_XML_SCHEMAP_S4S_ATTR_INVALID_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ELEMENT_1", _wrap_XML_SCHEMAP_SRC_ELEMENT_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ELEMENT_2_1", _wrap_XML_SCHEMAP_SRC_ELEMENT_2_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ELEMENT_2_2", _wrap_XML_SCHEMAP_SRC_ELEMENT_2_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ELEMENT_3", _wrap_XML_SCHEMAP_SRC_ELEMENT_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_P_PROPS_CORRECT_1", _wrap_XML_SCHEMAP_P_PROPS_CORRECT_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_P_PROPS_CORRECT_2_1", _wrap_XML_SCHEMAP_P_PROPS_CORRECT_2_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_P_PROPS_CORRECT_2_2", _wrap_XML_SCHEMAP_P_PROPS_CORRECT_2_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_E_PROPS_CORRECT_2", _wrap_XML_SCHEMAP_E_PROPS_CORRECT_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_E_PROPS_CORRECT_3", _wrap_XML_SCHEMAP_E_PROPS_CORRECT_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_E_PROPS_CORRECT_4", _wrap_XML_SCHEMAP_E_PROPS_CORRECT_4, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_E_PROPS_CORRECT_5", _wrap_XML_SCHEMAP_E_PROPS_CORRECT_5, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_E_PROPS_CORRECT_6", _wrap_XML_SCHEMAP_E_PROPS_CORRECT_6, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_INCLUDE", _wrap_XML_SCHEMAP_SRC_INCLUDE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ATTRIBUTE_1", _wrap_XML_SCHEMAP_SRC_ATTRIBUTE_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ATTRIBUTE_2", _wrap_XML_SCHEMAP_SRC_ATTRIBUTE_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ATTRIBUTE_3_1", _wrap_XML_SCHEMAP_SRC_ATTRIBUTE_3_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ATTRIBUTE_3_2", _wrap_XML_SCHEMAP_SRC_ATTRIBUTE_3_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ATTRIBUTE_4", _wrap_XML_SCHEMAP_SRC_ATTRIBUTE_4, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NO_XMLNS", _wrap_XML_SCHEMAP_NO_XMLNS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NO_XSI", _wrap_XML_SCHEMAP_NO_XSI, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_VALID_DEFAULT_1", _wrap_XML_SCHEMAP_COS_VALID_DEFAULT_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_VALID_DEFAULT_2_1", _wrap_XML_SCHEMAP_COS_VALID_DEFAULT_2_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1", _wrap_XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2", _wrap_XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_CVC_SIMPLE_TYPE", _wrap_XML_SCHEMAP_CVC_SIMPLE_TYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_CT_EXTENDS_1_1", _wrap_XML_SCHEMAP_COS_CT_EXTENDS_1_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_IMPORT_1_1", _wrap_XML_SCHEMAP_SRC_IMPORT_1_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_IMPORT_1_2", _wrap_XML_SCHEMAP_SRC_IMPORT_1_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_IMPORT_2", _wrap_XML_SCHEMAP_SRC_IMPORT_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_IMPORT_2_1", _wrap_XML_SCHEMAP_SRC_IMPORT_2_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_IMPORT_2_2", _wrap_XML_SCHEMAP_SRC_IMPORT_2_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_INTERNAL", _wrap_XML_SCHEMAP_INTERNAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_NOT_DETERMINISTIC", _wrap_XML_SCHEMAP_NOT_DETERMINISTIC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1", _wrap_XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2", _wrap_XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3", _wrap_XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_MG_PROPS_CORRECT_1", _wrap_XML_SCHEMAP_MG_PROPS_CORRECT_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_MG_PROPS_CORRECT_2", _wrap_XML_SCHEMAP_MG_PROPS_CORRECT_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_CT_1", _wrap_XML_SCHEMAP_SRC_CT_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3", _wrap_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_AU_PROPS_CORRECT_2", _wrap_XML_SCHEMAP_AU_PROPS_CORRECT_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_A_PROPS_CORRECT_2", _wrap_XML_SCHEMAP_A_PROPS_CORRECT_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_C_PROPS_CORRECT", _wrap_XML_SCHEMAP_C_PROPS_CORRECT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_REDEFINE", _wrap_XML_SCHEMAP_SRC_REDEFINE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_SRC_IMPORT", _wrap_XML_SCHEMAP_SRC_IMPORT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_WARN_SKIP_SCHEMA", _wrap_XML_SCHEMAP_WARN_SKIP_SCHEMA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_WARN_UNLOCATED_SCHEMA", _wrap_XML_SCHEMAP_WARN_UNLOCATED_SCHEMA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_WARN_ATTR_REDECL_PROH", _wrap_XML_SCHEMAP_WARN_ATTR_REDECL_PROH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH", _wrap_XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_AG_PROPS_CORRECT", _wrap_XML_SCHEMAP_AG_PROPS_CORRECT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_CT_EXTENDS_1_2", _wrap_XML_SCHEMAP_COS_CT_EXTENDS_1_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_AU_PROPS_CORRECT", _wrap_XML_SCHEMAP_AU_PROPS_CORRECT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_A_PROPS_CORRECT_3", _wrap_XML_SCHEMAP_A_PROPS_CORRECT_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAP_COS_ALL_LIMITED", _wrap_XML_SCHEMAP_COS_ALL_LIMITED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMATRONV_ASSERT", _wrap_XML_SCHEMATRONV_ASSERT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMATRONV_REPORT", _wrap_XML_SCHEMATRONV_REPORT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_MODULE_OPEN", _wrap_XML_MODULE_OPEN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_MODULE_CLOSE", _wrap_XML_MODULE_CLOSE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_ELEMENT", _wrap_XML_CHECK_FOUND_ELEMENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_ATTRIBUTE", _wrap_XML_CHECK_FOUND_ATTRIBUTE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_TEXT", _wrap_XML_CHECK_FOUND_TEXT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_CDATA", _wrap_XML_CHECK_FOUND_CDATA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_ENTITYREF", _wrap_XML_CHECK_FOUND_ENTITYREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_ENTITY", _wrap_XML_CHECK_FOUND_ENTITY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_PI", _wrap_XML_CHECK_FOUND_PI, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_COMMENT", _wrap_XML_CHECK_FOUND_COMMENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_DOCTYPE", _wrap_XML_CHECK_FOUND_DOCTYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_FRAGMENT", _wrap_XML_CHECK_FOUND_FRAGMENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_FOUND_NOTATION", _wrap_XML_CHECK_FOUND_NOTATION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_UNKNOWN_NODE", _wrap_XML_CHECK_UNKNOWN_NODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_ENTITY_TYPE", _wrap_XML_CHECK_ENTITY_TYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NO_PARENT", _wrap_XML_CHECK_NO_PARENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NO_DOC", _wrap_XML_CHECK_NO_DOC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NO_NAME", _wrap_XML_CHECK_NO_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NO_ELEM", _wrap_XML_CHECK_NO_ELEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_WRONG_DOC", _wrap_XML_CHECK_WRONG_DOC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NO_PREV", _wrap_XML_CHECK_NO_PREV, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_WRONG_PREV", _wrap_XML_CHECK_WRONG_PREV, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NO_NEXT", _wrap_XML_CHECK_NO_NEXT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_WRONG_NEXT", _wrap_XML_CHECK_WRONG_NEXT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NOT_DTD", _wrap_XML_CHECK_NOT_DTD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NOT_ATTR", _wrap_XML_CHECK_NOT_ATTR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NOT_ATTR_DECL", _wrap_XML_CHECK_NOT_ATTR_DECL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NOT_ELEM_DECL", _wrap_XML_CHECK_NOT_ELEM_DECL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NOT_ENTITY_DECL", _wrap_XML_CHECK_NOT_ENTITY_DECL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NOT_NS_DECL", _wrap_XML_CHECK_NOT_NS_DECL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NO_HREF", _wrap_XML_CHECK_NO_HREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_WRONG_PARENT", _wrap_XML_CHECK_WRONG_PARENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NS_SCOPE", _wrap_XML_CHECK_NS_SCOPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NS_ANCESTOR", _wrap_XML_CHECK_NS_ANCESTOR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NOT_UTF8", _wrap_XML_CHECK_NOT_UTF8, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NO_DICT", _wrap_XML_CHECK_NO_DICT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NOT_NCNAME", _wrap_XML_CHECK_NOT_NCNAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_OUTSIDE_DICT", _wrap_XML_CHECK_OUTSIDE_DICT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_WRONG_NAME", _wrap_XML_CHECK_WRONG_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHECK_NAME_NOT_NULL", _wrap_XML_CHECK_NAME_NOT_NULL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_I18N_NO_NAME", _wrap_XML_I18N_NO_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_I18N_NO_HANDLER", _wrap_XML_I18N_NO_HANDLER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_I18N_EXCESS_HANDLER", _wrap_XML_I18N_EXCESS_HANDLER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_I18N_CONV_FAILED", _wrap_XML_I18N_CONV_FAILED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_I18N_NO_OUTPUT", _wrap_XML_I18N_NO_OUTPUT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_BUF_OVERFLOW", _wrap_XML_BUF_OVERFLOW, 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, "finishDtd", _wrap__xmlValidCtxt_finishDtd_get, _wrap__xmlValidCtxt_finishDtd_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", _wrap_XML_INTERNAL_GENERAL_ENTITY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_EXTERNAL_GENERAL_PARSED_ENTITY", _wrap_XML_EXTERNAL_GENERAL_PARSED_ENTITY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_EXTERNAL_GENERAL_UNPARSED_ENTITY", _wrap_XML_EXTERNAL_GENERAL_UNPARSED_ENTITY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_INTERNAL_PARAMETER_ENTITY", _wrap_XML_INTERNAL_PARAMETER_ENTITY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_EXTERNAL_PARAMETER_ENTITY", _wrap_XML_EXTERNAL_PARAMETER_ENTITY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_INTERNAL_PREDEFINED_ENTITY", _wrap_XML_INTERNAL_PREDEFINED_ENTITY, JS_veto_set_variable, context);
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_DEFAULT_VERSION", _wrap_XML_DEFAULT_VERSION, 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, "standalone", _wrap__xmlParserInput_standalone_get, _wrap__xmlParserInput_standalone_set);
SWIGV8_AddMemberVariable(_exports__xmlParserInput_class, "id", _wrap__xmlParserInput_id_get, _wrap__xmlParserInput_id_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", _wrap_XML_PARSER_EOF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_START", _wrap_XML_PARSER_START, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_MISC", _wrap_XML_PARSER_MISC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_PI", _wrap_XML_PARSER_PI, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_DTD", _wrap_XML_PARSER_DTD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_PROLOG", _wrap_XML_PARSER_PROLOG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_COMMENT", _wrap_XML_PARSER_COMMENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_START_TAG", _wrap_XML_PARSER_START_TAG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_CONTENT", _wrap_XML_PARSER_CONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_CDATA_SECTION", _wrap_XML_PARSER_CDATA_SECTION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_END_TAG", _wrap_XML_PARSER_END_TAG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_ENTITY_DECL", _wrap_XML_PARSER_ENTITY_DECL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_ENTITY_VALUE", _wrap_XML_PARSER_ENTITY_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_ATTRIBUTE_VALUE", _wrap_XML_PARSER_ATTRIBUTE_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_SYSTEM_LITERAL", _wrap_XML_PARSER_SYSTEM_LITERAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_EPILOG", _wrap_XML_PARSER_EPILOG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_IGNORE", _wrap_XML_PARSER_IGNORE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_PUBLIC_LITERAL", _wrap_XML_PARSER_PUBLIC_LITERAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_DETECT_IDS", _wrap_XML_DETECT_IDS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_COMPLETE_ATTRS", _wrap_XML_COMPLETE_ATTRS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SKIP_IDS", _wrap_XML_SKIP_IDS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_UNKNOWN", _wrap_XML_PARSE_UNKNOWN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_DOM", _wrap_XML_PARSE_DOM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_SAX", _wrap_XML_PARSE_SAX, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_PUSH_DOM", _wrap_XML_PARSE_PUSH_DOM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_PUSH_SAX", _wrap_XML_PARSE_PUSH_SAX, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_READER", _wrap_XML_PARSE_READER, 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__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", _wrap_XML_SAX2_MAGIC, 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, "XML_CHAR_ENCODING_ERROR", _wrap_XML_CHAR_ENCODING_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_NONE", _wrap_XML_CHAR_ENCODING_NONE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_UTF8", _wrap_XML_CHAR_ENCODING_UTF8, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_UTF16LE", _wrap_XML_CHAR_ENCODING_UTF16LE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_UTF16BE", _wrap_XML_CHAR_ENCODING_UTF16BE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_UCS4LE", _wrap_XML_CHAR_ENCODING_UCS4LE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_UCS4BE", _wrap_XML_CHAR_ENCODING_UCS4BE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_EBCDIC", _wrap_XML_CHAR_ENCODING_EBCDIC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_UCS4_2143", _wrap_XML_CHAR_ENCODING_UCS4_2143, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_UCS4_3412", _wrap_XML_CHAR_ENCODING_UCS4_3412, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_UCS2", _wrap_XML_CHAR_ENCODING_UCS2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_1", _wrap_XML_CHAR_ENCODING_8859_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_2", _wrap_XML_CHAR_ENCODING_8859_2, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_3", _wrap_XML_CHAR_ENCODING_8859_3, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_4", _wrap_XML_CHAR_ENCODING_8859_4, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_5", _wrap_XML_CHAR_ENCODING_8859_5, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_6", _wrap_XML_CHAR_ENCODING_8859_6, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_7", _wrap_XML_CHAR_ENCODING_8859_7, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_8", _wrap_XML_CHAR_ENCODING_8859_8, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_8859_9", _wrap_XML_CHAR_ENCODING_8859_9, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_2022_JP", _wrap_XML_CHAR_ENCODING_2022_JP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_SHIFT_JIS", _wrap_XML_CHAR_ENCODING_SHIFT_JIS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_EUC_JP", _wrap_XML_CHAR_ENCODING_EUC_JP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CHAR_ENCODING_ASCII", _wrap_XML_CHAR_ENCODING_ASCII, 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_AddStaticVariable(exports_obj, "XLINK_TYPE_NONE", _wrap_XLINK_TYPE_NONE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_TYPE_SIMPLE", _wrap_XLINK_TYPE_SIMPLE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_TYPE_EXTENDED", _wrap_XLINK_TYPE_EXTENDED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_TYPE_EXTENDED_SET", _wrap_XLINK_TYPE_EXTENDED_SET, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_SHOW_NONE", _wrap_XLINK_SHOW_NONE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_SHOW_NEW", _wrap_XLINK_SHOW_NEW, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_SHOW_EMBED", _wrap_XLINK_SHOW_EMBED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_SHOW_REPLACE", _wrap_XLINK_SHOW_REPLACE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_ACTUATE_NONE", _wrap_XLINK_ACTUATE_NONE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_ACTUATE_AUTO", _wrap_XLINK_ACTUATE_AUTO, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XLINK_ACTUATE_ONREQUEST", _wrap_XLINK_ACTUATE_ONREQUEST, 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, "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, "docbDefaultSAXHandler", _wrap_docbDefaultSAXHandler_get, _wrap_docbDefaultSAXHandler_set, context);
SWIGV8_AddStaticVariable(exports_obj, "htmlDefaultSAXHandler", _wrap_htmlDefaultSAXHandler_get, _wrap_htmlDefaultSAXHandler_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlLastError", _wrap_xmlLastError_get, _wrap_xmlLastError_set, context);
SWIGV8_AddStaticVariable(exports_obj, "oldXMLWDcompatibility", _wrap_oldXMLWDcompatibility_get, _wrap_oldXMLWDcompatibility_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlBufferAllocScheme", _wrap_xmlBufferAllocScheme_get, _wrap_xmlBufferAllocScheme_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlDefaultBufferSize", _wrap_xmlDefaultBufferSize_get, _wrap_xmlDefaultBufferSize_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlDefaultSAXHandler", _wrap_xmlDefaultSAXHandler_get, _wrap_xmlDefaultSAXHandler_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlDefaultSAXLocator", _wrap_xmlDefaultSAXLocator_get, _wrap_xmlDefaultSAXLocator_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlDoValidityCheckingDefaultValue", _wrap_xmlDoValidityCheckingDefaultValue_get, _wrap_xmlDoValidityCheckingDefaultValue_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlGenericError", _wrap_xmlGenericError_get, _wrap_xmlGenericError_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlStructuredError", _wrap_xmlStructuredError_get, _wrap_xmlStructuredError_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlGenericErrorContext", _wrap_xmlGenericErrorContext_get, _wrap_xmlGenericErrorContext_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlStructuredErrorContext", _wrap_xmlStructuredErrorContext_get, _wrap_xmlStructuredErrorContext_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlGetWarningsDefaultValue", _wrap_xmlGetWarningsDefaultValue_get, _wrap_xmlGetWarningsDefaultValue_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlIndentTreeOutput", _wrap_xmlIndentTreeOutput_get, _wrap_xmlIndentTreeOutput_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlTreeIndentString", _wrap_xmlTreeIndentString_get, _wrap_xmlTreeIndentString_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlKeepBlanksDefaultValue", _wrap_xmlKeepBlanksDefaultValue_get, _wrap_xmlKeepBlanksDefaultValue_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlLineNumbersDefaultValue", _wrap_xmlLineNumbersDefaultValue_get, _wrap_xmlLineNumbersDefaultValue_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlLoadExtDtdDefaultValue", _wrap_xmlLoadExtDtdDefaultValue_get, _wrap_xmlLoadExtDtdDefaultValue_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlParserDebugEntities", _wrap_xmlParserDebugEntities_get, _wrap_xmlParserDebugEntities_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlParserVersion", _wrap_xmlParserVersion_get, _wrap_xmlParserVersion_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlPedanticParserDefaultValue", _wrap_xmlPedanticParserDefaultValue_get, _wrap_xmlPedanticParserDefaultValue_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlSaveNoEmptyTags", _wrap_xmlSaveNoEmptyTags_get, _wrap_xmlSaveNoEmptyTags_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlSubstituteEntitiesDefaultValue", _wrap_xmlSubstituteEntitiesDefaultValue_get, _wrap_xmlSubstituteEntitiesDefaultValue_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlRegisterNodeDefaultValue", _wrap_xmlRegisterNodeDefaultValue_get, _wrap_xmlRegisterNodeDefaultValue_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlDeregisterNodeDefaultValue", _wrap_xmlDeregisterNodeDefaultValue_get, _wrap_xmlDeregisterNodeDefaultValue_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlParserInputBufferCreateFilenameValue", _wrap_xmlParserInputBufferCreateFilenameValue_get, _wrap_xmlParserInputBufferCreateFilenameValue_set, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlOutputBufferCreateFilenameValue", _wrap_xmlOutputBufferCreateFilenameValue_get, _wrap_xmlOutputBufferCreateFilenameValue_set, context);
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_PARSE_RECOVER", _wrap_XML_PARSE_RECOVER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NOENT", _wrap_XML_PARSE_NOENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_DTDLOAD", _wrap_XML_PARSE_DTDLOAD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_DTDATTR", _wrap_XML_PARSE_DTDATTR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_DTDVALID", _wrap_XML_PARSE_DTDVALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NOERROR", _wrap_XML_PARSE_NOERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NOWARNING", _wrap_XML_PARSE_NOWARNING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_PEDANTIC", _wrap_XML_PARSE_PEDANTIC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NOBLANKS", _wrap_XML_PARSE_NOBLANKS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_SAX1", _wrap_XML_PARSE_SAX1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_XINCLUDE", _wrap_XML_PARSE_XINCLUDE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NONET", _wrap_XML_PARSE_NONET, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NODICT", _wrap_XML_PARSE_NODICT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NSCLEAN", _wrap_XML_PARSE_NSCLEAN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NOCDATA", _wrap_XML_PARSE_NOCDATA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NOXINCNODE", _wrap_XML_PARSE_NOXINCNODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_COMPACT", _wrap_XML_PARSE_COMPACT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_OLD10", _wrap_XML_PARSE_OLD10, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_NOBASEFIX", _wrap_XML_PARSE_NOBASEFIX, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_HUGE", _wrap_XML_PARSE_HUGE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_OLDSAX", _wrap_XML_PARSE_OLDSAX, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_IGNORE_ENC", _wrap_XML_PARSE_IGNORE_ENC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSE_BIG_LINES", _wrap_XML_PARSE_BIG_LINES, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_THREAD", _wrap_XML_WITH_THREAD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_TREE", _wrap_XML_WITH_TREE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_OUTPUT", _wrap_XML_WITH_OUTPUT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_PUSH", _wrap_XML_WITH_PUSH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_READER", _wrap_XML_WITH_READER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_PATTERN", _wrap_XML_WITH_PATTERN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_WRITER", _wrap_XML_WITH_WRITER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_SAX1", _wrap_XML_WITH_SAX1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_FTP", _wrap_XML_WITH_FTP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_HTTP", _wrap_XML_WITH_HTTP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_VALID", _wrap_XML_WITH_VALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_HTML", _wrap_XML_WITH_HTML, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_LEGACY", _wrap_XML_WITH_LEGACY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_C14N", _wrap_XML_WITH_C14N, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_CATALOG", _wrap_XML_WITH_CATALOG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_XPATH", _wrap_XML_WITH_XPATH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_XPTR", _wrap_XML_WITH_XPTR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_XINCLUDE", _wrap_XML_WITH_XINCLUDE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_ICONV", _wrap_XML_WITH_ICONV, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_ISO8859X", _wrap_XML_WITH_ISO8859X, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_UNICODE", _wrap_XML_WITH_UNICODE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_REGEXP", _wrap_XML_WITH_REGEXP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_AUTOMATA", _wrap_XML_WITH_AUTOMATA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_EXPR", _wrap_XML_WITH_EXPR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_SCHEMAS", _wrap_XML_WITH_SCHEMAS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_SCHEMATRON", _wrap_XML_WITH_SCHEMATRON, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_MODULES", _wrap_XML_WITH_MODULES, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_DEBUG", _wrap_XML_WITH_DEBUG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_DEBUG_MEM", _wrap_XML_WITH_DEBUG_MEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_DEBUG_RUN", _wrap_XML_WITH_DEBUG_RUN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_ZLIB", _wrap_XML_WITH_ZLIB, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_ICU", _wrap_XML_WITH_ICU, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_LZMA", _wrap_XML_WITH_LZMA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_WITH_NONE", _wrap_XML_WITH_NONE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_EXPRESSION_OK", _wrap_XPATH_EXPRESSION_OK, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_NUMBER_ERROR", _wrap_XPATH_NUMBER_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_UNFINISHED_LITERAL_ERROR", _wrap_XPATH_UNFINISHED_LITERAL_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_START_LITERAL_ERROR", _wrap_XPATH_START_LITERAL_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_VARIABLE_REF_ERROR", _wrap_XPATH_VARIABLE_REF_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_UNDEF_VARIABLE_ERROR", _wrap_XPATH_UNDEF_VARIABLE_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_INVALID_PREDICATE_ERROR", _wrap_XPATH_INVALID_PREDICATE_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_EXPR_ERROR", _wrap_XPATH_EXPR_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_UNCLOSED_ERROR", _wrap_XPATH_UNCLOSED_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_UNKNOWN_FUNC_ERROR", _wrap_XPATH_UNKNOWN_FUNC_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_INVALID_OPERAND", _wrap_XPATH_INVALID_OPERAND, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_INVALID_TYPE", _wrap_XPATH_INVALID_TYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_INVALID_ARITY", _wrap_XPATH_INVALID_ARITY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_INVALID_CTXT_SIZE", _wrap_XPATH_INVALID_CTXT_SIZE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_INVALID_CTXT_POSITION", _wrap_XPATH_INVALID_CTXT_POSITION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_MEMORY_ERROR", _wrap_XPATH_MEMORY_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPTR_SYNTAX_ERROR", _wrap_XPTR_SYNTAX_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPTR_RESOURCE_ERROR", _wrap_XPTR_RESOURCE_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPTR_SUB_RESOURCE_ERROR", _wrap_XPTR_SUB_RESOURCE_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_UNDEF_PREFIX_ERROR", _wrap_XPATH_UNDEF_PREFIX_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_ENCODING_ERROR", _wrap_XPATH_ENCODING_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_INVALID_CHAR_ERROR", _wrap_XPATH_INVALID_CHAR_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_INVALID_CTXT", _wrap_XPATH_INVALID_CTXT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_STACK_ERROR", _wrap_XPATH_STACK_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_FORBID_VARIABLE_ERROR", _wrap_XPATH_FORBID_VARIABLE_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_OP_LIMIT_EXCEEDED", _wrap_XPATH_OP_LIMIT_EXCEEDED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_RECURSION_LIMIT_EXCEEDED", _wrap_XPATH_RECURSION_LIMIT_EXCEEDED, 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", _wrap_XPATH_UNDEFINED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_NODESET", _wrap_XPATH_NODESET, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_BOOLEAN", _wrap_XPATH_BOOLEAN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_NUMBER", _wrap_XPATH_NUMBER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_STRING", _wrap_XPATH_STRING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_POINT", _wrap_XPATH_POINT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_RANGE", _wrap_XPATH_RANGE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_LOCATIONSET", _wrap_XPATH_LOCATIONSET, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_USERS", _wrap_XPATH_USERS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XPATH_XSLT_TREE", _wrap_XPATH_XSLT_TREE, 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", _wrap_XML_XPATH_CHECKNS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_XPATH_NOVAR", _wrap_XML_XPATH_NOVAR, 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", _wrap_XML_CATA_PREFER_NONE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATA_PREFER_PUBLIC", _wrap_XML_CATA_PREFER_PUBLIC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATA_PREFER_SYSTEM", _wrap_XML_CATA_PREFER_SYSTEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATA_ALLOW_NONE", _wrap_XML_CATA_ALLOW_NONE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATA_ALLOW_GLOBAL", _wrap_XML_CATA_ALLOW_GLOBAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATA_ALLOW_DOCUMENT", _wrap_XML_CATA_ALLOW_DOCUMENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_CATA_ALLOW_ALL", _wrap_XML_CATA_ALLOW_ALL, 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, "HTML_PARSE_RECOVER", _wrap_HTML_PARSE_RECOVER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_NODEFDTD", _wrap_HTML_PARSE_NODEFDTD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_NOERROR", _wrap_HTML_PARSE_NOERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_NOWARNING", _wrap_HTML_PARSE_NOWARNING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_PEDANTIC", _wrap_HTML_PARSE_PEDANTIC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_NOBLANKS", _wrap_HTML_PARSE_NOBLANKS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_NONET", _wrap_HTML_PARSE_NONET, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_NOIMPLIED", _wrap_HTML_PARSE_NOIMPLIED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_COMPACT", _wrap_HTML_PARSE_COMPACT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_PARSE_IGNORE_ENC", _wrap_HTML_PARSE_IGNORE_ENC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_NA", _wrap_HTML_NA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_INVALID", _wrap_HTML_INVALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_DEPRECATED", _wrap_HTML_DEPRECATED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_VALID", _wrap_HTML_VALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "HTML_REQUIRED", _wrap_HTML_REQUIRED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "xmlParserMaxDepth", _wrap_xmlParserMaxDepth_get, _wrap_xmlParserMaxDepth_set, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_MAX_TEXT_LENGTH", _wrap_XML_MAX_TEXT_LENGTH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_MAX_NAME_LENGTH", _wrap_XML_MAX_NAME_LENGTH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_MAX_DICTIONARY_LIMIT", _wrap_XML_MAX_DICTIONARY_LIMIT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_MAX_LOOKUP_LIMIT", _wrap_XML_MAX_LOOKUP_LIMIT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_MAX_NAMELEN", _wrap_XML_MAX_NAMELEN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "INPUT_CHUNK", _wrap_INPUT_CHUNK, 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", _wrap_XML_SUBSTITUTE_NONE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SUBSTITUTE_REF", _wrap_XML_SUBSTITUTE_REF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SUBSTITUTE_PEREF", _wrap_XML_SUBSTITUTE_PEREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SUBSTITUTE_BOTH", _wrap_XML_SUBSTITUTE_BOTH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PATTERN_DEFAULT", _wrap_XML_PATTERN_DEFAULT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PATTERN_XPATH", _wrap_XML_PATTERN_XPATH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PATTERN_XSSEL", _wrap_XML_PATTERN_XSSEL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PATTERN_XSFIELD", _wrap_XML_PATTERN_XSFIELD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_OK", _wrap_XML_RELAXNG_OK, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_MEMORY", _wrap_XML_RELAXNG_ERR_MEMORY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_TYPE", _wrap_XML_RELAXNG_ERR_TYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_TYPEVAL", _wrap_XML_RELAXNG_ERR_TYPEVAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_DUPID", _wrap_XML_RELAXNG_ERR_DUPID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_TYPECMP", _wrap_XML_RELAXNG_ERR_TYPECMP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_NOSTATE", _wrap_XML_RELAXNG_ERR_NOSTATE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_NODEFINE", _wrap_XML_RELAXNG_ERR_NODEFINE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_LISTEXTRA", _wrap_XML_RELAXNG_ERR_LISTEXTRA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_LISTEMPTY", _wrap_XML_RELAXNG_ERR_LISTEMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_INTERNODATA", _wrap_XML_RELAXNG_ERR_INTERNODATA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_INTERSEQ", _wrap_XML_RELAXNG_ERR_INTERSEQ, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_INTEREXTRA", _wrap_XML_RELAXNG_ERR_INTEREXTRA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ELEMNAME", _wrap_XML_RELAXNG_ERR_ELEMNAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ATTRNAME", _wrap_XML_RELAXNG_ERR_ATTRNAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ELEMNONS", _wrap_XML_RELAXNG_ERR_ELEMNONS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ATTRNONS", _wrap_XML_RELAXNG_ERR_ATTRNONS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ELEMWRONGNS", _wrap_XML_RELAXNG_ERR_ELEMWRONGNS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ATTRWRONGNS", _wrap_XML_RELAXNG_ERR_ATTRWRONGNS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ELEMEXTRANS", _wrap_XML_RELAXNG_ERR_ELEMEXTRANS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ATTREXTRANS", _wrap_XML_RELAXNG_ERR_ATTREXTRANS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ELEMNOTEMPTY", _wrap_XML_RELAXNG_ERR_ELEMNOTEMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_NOELEM", _wrap_XML_RELAXNG_ERR_NOELEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_NOTELEM", _wrap_XML_RELAXNG_ERR_NOTELEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ATTRVALID", _wrap_XML_RELAXNG_ERR_ATTRVALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_CONTENTVALID", _wrap_XML_RELAXNG_ERR_CONTENTVALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_EXTRACONTENT", _wrap_XML_RELAXNG_ERR_EXTRACONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_INVALIDATTR", _wrap_XML_RELAXNG_ERR_INVALIDATTR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_DATAELEM", _wrap_XML_RELAXNG_ERR_DATAELEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_VALELEM", _wrap_XML_RELAXNG_ERR_VALELEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_LISTELEM", _wrap_XML_RELAXNG_ERR_LISTELEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_DATATYPE", _wrap_XML_RELAXNG_ERR_DATATYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_VALUE", _wrap_XML_RELAXNG_ERR_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_LIST", _wrap_XML_RELAXNG_ERR_LIST, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_NOGRAMMAR", _wrap_XML_RELAXNG_ERR_NOGRAMMAR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_EXTRADATA", _wrap_XML_RELAXNG_ERR_EXTRADATA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_LACKDATA", _wrap_XML_RELAXNG_ERR_LACKDATA, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_INTERNAL", _wrap_XML_RELAXNG_ERR_INTERNAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_ELEMWRONG", _wrap_XML_RELAXNG_ERR_ELEMWRONG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNG_ERR_TEXTWRONG", _wrap_XML_RELAXNG_ERR_TEXTWRONG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNGP_NONE", _wrap_XML_RELAXNGP_NONE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNGP_FREE_DOC", _wrap_XML_RELAXNGP_FREE_DOC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_RELAXNGP_CRNG", _wrap_XML_RELAXNGP_CRNG, 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, "XML_MODULE_LAZY", _wrap_XML_MODULE_LAZY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_MODULE_LOCAL", _wrap_XML_MODULE_LOCAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_OK", _wrap_XML_SCHEMAS_ERR_OK, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_NOROOT", _wrap_XML_SCHEMAS_ERR_NOROOT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_UNDECLAREDELEM", _wrap_XML_SCHEMAS_ERR_UNDECLAREDELEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_NOTTOPLEVEL", _wrap_XML_SCHEMAS_ERR_NOTTOPLEVEL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_MISSING", _wrap_XML_SCHEMAS_ERR_MISSING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_WRONGELEM", _wrap_XML_SCHEMAS_ERR_WRONGELEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_NOTYPE", _wrap_XML_SCHEMAS_ERR_NOTYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_NOROLLBACK", _wrap_XML_SCHEMAS_ERR_NOROLLBACK, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_ISABSTRACT", _wrap_XML_SCHEMAS_ERR_ISABSTRACT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_NOTEMPTY", _wrap_XML_SCHEMAS_ERR_NOTEMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_ELEMCONT", _wrap_XML_SCHEMAS_ERR_ELEMCONT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_HAVEDEFAULT", _wrap_XML_SCHEMAS_ERR_HAVEDEFAULT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_NOTNILLABLE", _wrap_XML_SCHEMAS_ERR_NOTNILLABLE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_EXTRACONTENT", _wrap_XML_SCHEMAS_ERR_EXTRACONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_INVALIDATTR", _wrap_XML_SCHEMAS_ERR_INVALIDATTR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_INVALIDELEM", _wrap_XML_SCHEMAS_ERR_INVALIDELEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_NOTDETERMINIST", _wrap_XML_SCHEMAS_ERR_NOTDETERMINIST, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_CONSTRUCT", _wrap_XML_SCHEMAS_ERR_CONSTRUCT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_INTERNAL", _wrap_XML_SCHEMAS_ERR_INTERNAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_NOTSIMPLE", _wrap_XML_SCHEMAS_ERR_NOTSIMPLE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_ATTRUNKNOWN", _wrap_XML_SCHEMAS_ERR_ATTRUNKNOWN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_ATTRINVALID", _wrap_XML_SCHEMAS_ERR_ATTRINVALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_VALUE", _wrap_XML_SCHEMAS_ERR_VALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_FACET", _wrap_XML_SCHEMAS_ERR_FACET, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_", _wrap_XML_SCHEMAS_ERR_, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ERR_XXX", _wrap_XML_SCHEMAS_ERR_XXX, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_VAL_VC_I_CREATE", _wrap_XML_SCHEMA_VAL_VC_I_CREATE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_SEVERITY_VALIDITY_WARNING", _wrap_XML_PARSER_SEVERITY_VALIDITY_WARNING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_SEVERITY_VALIDITY_ERROR", _wrap_XML_PARSER_SEVERITY_VALIDITY_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_SEVERITY_WARNING", _wrap_XML_PARSER_SEVERITY_WARNING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_PARSER_SEVERITY_ERROR", _wrap_XML_PARSER_SEVERITY_ERROR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_FORMAT", _wrap_XML_SAVE_FORMAT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_NO_DECL", _wrap_XML_SAVE_NO_DECL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_NO_EMPTY", _wrap_XML_SAVE_NO_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_NO_XHTML", _wrap_XML_SAVE_NO_XHTML, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_XHTML", _wrap_XML_SAVE_XHTML, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_AS_XML", _wrap_XML_SAVE_AS_XML, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_AS_HTML", _wrap_XML_SAVE_AS_HTML, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SAVE_WSNONSIG", _wrap_XML_SAVE_WSNONSIG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_UNKNOWN", _wrap_XML_SCHEMAS_UNKNOWN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_STRING", _wrap_XML_SCHEMAS_STRING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NORMSTRING", _wrap_XML_SCHEMAS_NORMSTRING, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_DECIMAL", _wrap_XML_SCHEMAS_DECIMAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TIME", _wrap_XML_SCHEMAS_TIME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_GDAY", _wrap_XML_SCHEMAS_GDAY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_GMONTH", _wrap_XML_SCHEMAS_GMONTH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_GMONTHDAY", _wrap_XML_SCHEMAS_GMONTHDAY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_GYEAR", _wrap_XML_SCHEMAS_GYEAR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_GYEARMONTH", _wrap_XML_SCHEMAS_GYEARMONTH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_DATE", _wrap_XML_SCHEMAS_DATE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_DATETIME", _wrap_XML_SCHEMAS_DATETIME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_DURATION", _wrap_XML_SCHEMAS_DURATION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_FLOAT", _wrap_XML_SCHEMAS_FLOAT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_DOUBLE", _wrap_XML_SCHEMAS_DOUBLE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_BOOLEAN", _wrap_XML_SCHEMAS_BOOLEAN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TOKEN", _wrap_XML_SCHEMAS_TOKEN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_LANGUAGE", _wrap_XML_SCHEMAS_LANGUAGE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NMTOKEN", _wrap_XML_SCHEMAS_NMTOKEN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NMTOKENS", _wrap_XML_SCHEMAS_NMTOKENS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NAME", _wrap_XML_SCHEMAS_NAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_QNAME", _wrap_XML_SCHEMAS_QNAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NCNAME", _wrap_XML_SCHEMAS_NCNAME, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ID", _wrap_XML_SCHEMAS_ID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_IDREF", _wrap_XML_SCHEMAS_IDREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_IDREFS", _wrap_XML_SCHEMAS_IDREFS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ENTITY", _wrap_XML_SCHEMAS_ENTITY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ENTITIES", _wrap_XML_SCHEMAS_ENTITIES, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NOTATION", _wrap_XML_SCHEMAS_NOTATION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ANYURI", _wrap_XML_SCHEMAS_ANYURI, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_INTEGER", _wrap_XML_SCHEMAS_INTEGER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NPINTEGER", _wrap_XML_SCHEMAS_NPINTEGER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NINTEGER", _wrap_XML_SCHEMAS_NINTEGER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_NNINTEGER", _wrap_XML_SCHEMAS_NNINTEGER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_PINTEGER", _wrap_XML_SCHEMAS_PINTEGER, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_INT", _wrap_XML_SCHEMAS_INT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_UINT", _wrap_XML_SCHEMAS_UINT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_LONG", _wrap_XML_SCHEMAS_LONG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ULONG", _wrap_XML_SCHEMAS_ULONG, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_SHORT", _wrap_XML_SCHEMAS_SHORT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_USHORT", _wrap_XML_SCHEMAS_USHORT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_BYTE", _wrap_XML_SCHEMAS_BYTE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_UBYTE", _wrap_XML_SCHEMAS_UBYTE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_HEXBINARY", _wrap_XML_SCHEMAS_HEXBINARY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_BASE64BINARY", _wrap_XML_SCHEMAS_BASE64BINARY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ANYTYPE", _wrap_XML_SCHEMAS_ANYTYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ANYSIMPLETYPE", _wrap_XML_SCHEMAS_ANYSIMPLETYPE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_BASIC", _wrap_XML_SCHEMA_TYPE_BASIC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_ANY", _wrap_XML_SCHEMA_TYPE_ANY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_FACET", _wrap_XML_SCHEMA_TYPE_FACET, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_SIMPLE", _wrap_XML_SCHEMA_TYPE_SIMPLE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_COMPLEX", _wrap_XML_SCHEMA_TYPE_COMPLEX, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_SEQUENCE", _wrap_XML_SCHEMA_TYPE_SEQUENCE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_CHOICE", _wrap_XML_SCHEMA_TYPE_CHOICE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_ALL", _wrap_XML_SCHEMA_TYPE_ALL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_SIMPLE_CONTENT", _wrap_XML_SCHEMA_TYPE_SIMPLE_CONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_COMPLEX_CONTENT", _wrap_XML_SCHEMA_TYPE_COMPLEX_CONTENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_UR", _wrap_XML_SCHEMA_TYPE_UR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_RESTRICTION", _wrap_XML_SCHEMA_TYPE_RESTRICTION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_EXTENSION", _wrap_XML_SCHEMA_TYPE_EXTENSION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_ELEMENT", _wrap_XML_SCHEMA_TYPE_ELEMENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_ATTRIBUTE", _wrap_XML_SCHEMA_TYPE_ATTRIBUTE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_ATTRIBUTEGROUP", _wrap_XML_SCHEMA_TYPE_ATTRIBUTEGROUP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_GROUP", _wrap_XML_SCHEMA_TYPE_GROUP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_NOTATION", _wrap_XML_SCHEMA_TYPE_NOTATION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_LIST", _wrap_XML_SCHEMA_TYPE_LIST, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_UNION", _wrap_XML_SCHEMA_TYPE_UNION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_ANY_ATTRIBUTE", _wrap_XML_SCHEMA_TYPE_ANY_ATTRIBUTE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_IDC_UNIQUE", _wrap_XML_SCHEMA_TYPE_IDC_UNIQUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_IDC_KEY", _wrap_XML_SCHEMA_TYPE_IDC_KEY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_IDC_KEYREF", _wrap_XML_SCHEMA_TYPE_IDC_KEYREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_PARTICLE", _wrap_XML_SCHEMA_TYPE_PARTICLE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_TYPE_ATTRIBUTE_USE", _wrap_XML_SCHEMA_TYPE_ATTRIBUTE_USE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_MININCLUSIVE", _wrap_XML_SCHEMA_FACET_MININCLUSIVE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_MINEXCLUSIVE", _wrap_XML_SCHEMA_FACET_MINEXCLUSIVE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_MAXINCLUSIVE", _wrap_XML_SCHEMA_FACET_MAXINCLUSIVE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_MAXEXCLUSIVE", _wrap_XML_SCHEMA_FACET_MAXEXCLUSIVE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_TOTALDIGITS", _wrap_XML_SCHEMA_FACET_TOTALDIGITS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_FRACTIONDIGITS", _wrap_XML_SCHEMA_FACET_FRACTIONDIGITS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_PATTERN", _wrap_XML_SCHEMA_FACET_PATTERN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_ENUMERATION", _wrap_XML_SCHEMA_FACET_ENUMERATION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_WHITESPACE", _wrap_XML_SCHEMA_FACET_WHITESPACE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_LENGTH", _wrap_XML_SCHEMA_FACET_LENGTH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_MAXLENGTH", _wrap_XML_SCHEMA_FACET_MAXLENGTH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_FACET_MINLENGTH", _wrap_XML_SCHEMA_FACET_MINLENGTH, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_EXTRA_QNAMEREF", _wrap_XML_SCHEMA_EXTRA_QNAMEREF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_EXTRA_ATTR_USE_PROHIB", _wrap_XML_SCHEMA_EXTRA_ATTR_USE_PROHIB, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_CONTENT_UNKNOWN", _wrap_XML_SCHEMA_CONTENT_UNKNOWN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_CONTENT_EMPTY", _wrap_XML_SCHEMA_CONTENT_EMPTY, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_CONTENT_ELEMENTS", _wrap_XML_SCHEMA_CONTENT_ELEMENTS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_CONTENT_MIXED", _wrap_XML_SCHEMA_CONTENT_MIXED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_CONTENT_SIMPLE", _wrap_XML_SCHEMA_CONTENT_SIMPLE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS", _wrap_XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_CONTENT_BASIC", _wrap_XML_SCHEMA_CONTENT_BASIC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_CONTENT_ANY", _wrap_XML_SCHEMA_CONTENT_ANY, 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", _wrap_XML_SCHEMAS_ANYATTR_SKIP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ANYATTR_LAX", _wrap_XML_SCHEMAS_ANYATTR_LAX, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ANYATTR_STRICT", _wrap_XML_SCHEMAS_ANYATTR_STRICT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ANY_SKIP", _wrap_XML_SCHEMAS_ANY_SKIP, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ANY_LAX", _wrap_XML_SCHEMAS_ANY_LAX, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ANY_STRICT", _wrap_XML_SCHEMAS_ANY_STRICT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTR_USE_PROHIBITED", _wrap_XML_SCHEMAS_ATTR_USE_PROHIBITED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTR_USE_REQUIRED", _wrap_XML_SCHEMAS_ATTR_USE_REQUIRED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTR_USE_OPTIONAL", _wrap_XML_SCHEMAS_ATTR_USE_OPTIONAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTR_GLOBAL", _wrap_XML_SCHEMAS_ATTR_GLOBAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTR_NSDEFAULT", _wrap_XML_SCHEMAS_ATTR_NSDEFAULT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTR_INTERNAL_RESOLVED", _wrap_XML_SCHEMAS_ATTR_INTERNAL_RESOLVED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTR_FIXED", _wrap_XML_SCHEMAS_ATTR_FIXED, 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", _wrap_XML_SCHEMAS_WILDCARD_COMPLETE, 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", _wrap_XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTRGROUP_GLOBAL", _wrap_XML_SCHEMAS_ATTRGROUP_GLOBAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTRGROUP_MARKED", _wrap_XML_SCHEMAS_ATTRGROUP_MARKED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTRGROUP_REDEFINED", _wrap_XML_SCHEMAS_ATTRGROUP_REDEFINED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ATTRGROUP_HAS_REFS", _wrap_XML_SCHEMAS_ATTRGROUP_HAS_REFS, 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", _wrap_XML_SCHEMAS_TYPE_MIXED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION", _wrap_XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION", _wrap_XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_GLOBAL", _wrap_XML_SCHEMAS_TYPE_GLOBAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD", _wrap_XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_VARIETY_ABSENT", _wrap_XML_SCHEMAS_TYPE_VARIETY_ABSENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_VARIETY_LIST", _wrap_XML_SCHEMAS_TYPE_VARIETY_LIST, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_VARIETY_UNION", _wrap_XML_SCHEMAS_TYPE_VARIETY_UNION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_VARIETY_ATOMIC", _wrap_XML_SCHEMAS_TYPE_VARIETY_ATOMIC, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_FINAL_EXTENSION", _wrap_XML_SCHEMAS_TYPE_FINAL_EXTENSION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_FINAL_RESTRICTION", _wrap_XML_SCHEMAS_TYPE_FINAL_RESTRICTION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_FINAL_LIST", _wrap_XML_SCHEMAS_TYPE_FINAL_LIST, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_FINAL_UNION", _wrap_XML_SCHEMAS_TYPE_FINAL_UNION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_FINAL_DEFAULT", _wrap_XML_SCHEMAS_TYPE_FINAL_DEFAULT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE", _wrap_XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_MARKED", _wrap_XML_SCHEMAS_TYPE_MARKED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_BLOCK_DEFAULT", _wrap_XML_SCHEMAS_TYPE_BLOCK_DEFAULT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_BLOCK_EXTENSION", _wrap_XML_SCHEMAS_TYPE_BLOCK_EXTENSION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_BLOCK_RESTRICTION", _wrap_XML_SCHEMAS_TYPE_BLOCK_RESTRICTION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_ABSTRACT", _wrap_XML_SCHEMAS_TYPE_ABSTRACT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_FACETSNEEDVALUE", _wrap_XML_SCHEMAS_TYPE_FACETSNEEDVALUE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_INTERNAL_RESOLVED", _wrap_XML_SCHEMAS_TYPE_INTERNAL_RESOLVED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_INTERNAL_INVALID", _wrap_XML_SCHEMAS_TYPE_INTERNAL_INVALID, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE", _wrap_XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_WHITESPACE_REPLACE", _wrap_XML_SCHEMAS_TYPE_WHITESPACE_REPLACE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE", _wrap_XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_HAS_FACETS", _wrap_XML_SCHEMAS_TYPE_HAS_FACETS, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_NORMVALUENEEDED", _wrap_XML_SCHEMAS_TYPE_NORMVALUENEEDED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_FIXUP_1", _wrap_XML_SCHEMAS_TYPE_FIXUP_1, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_TYPE_REDEFINED", _wrap_XML_SCHEMAS_TYPE_REDEFINED, 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", _wrap_XML_SCHEMAS_ELEM_NILLABLE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_GLOBAL", _wrap_XML_SCHEMAS_ELEM_GLOBAL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_DEFAULT", _wrap_XML_SCHEMAS_ELEM_DEFAULT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_FIXED", _wrap_XML_SCHEMAS_ELEM_FIXED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_ABSTRACT", _wrap_XML_SCHEMAS_ELEM_ABSTRACT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_TOPLEVEL", _wrap_XML_SCHEMAS_ELEM_TOPLEVEL, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_REF", _wrap_XML_SCHEMAS_ELEM_REF, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_NSDEFAULT", _wrap_XML_SCHEMAS_ELEM_NSDEFAULT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_INTERNAL_RESOLVED", _wrap_XML_SCHEMAS_ELEM_INTERNAL_RESOLVED, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_CIRCULAR", _wrap_XML_SCHEMAS_ELEM_CIRCULAR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_BLOCK_ABSENT", _wrap_XML_SCHEMAS_ELEM_BLOCK_ABSENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_BLOCK_EXTENSION", _wrap_XML_SCHEMAS_ELEM_BLOCK_EXTENSION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_BLOCK_RESTRICTION", _wrap_XML_SCHEMAS_ELEM_BLOCK_RESTRICTION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION", _wrap_XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_FINAL_ABSENT", _wrap_XML_SCHEMAS_ELEM_FINAL_ABSENT, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_FINAL_EXTENSION", _wrap_XML_SCHEMAS_ELEM_FINAL_EXTENSION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_FINAL_RESTRICTION", _wrap_XML_SCHEMAS_ELEM_FINAL_RESTRICTION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD", _wrap_XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_ELEM_INTERNAL_CHECKED", _wrap_XML_SCHEMAS_ELEM_INTERNAL_CHECKED, 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", _wrap_XML_SCHEMAS_FACET_UNKNOWN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_FACET_PRESERVE", _wrap_XML_SCHEMAS_FACET_PRESERVE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_FACET_REPLACE", _wrap_XML_SCHEMAS_FACET_REPLACE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_FACET_COLLAPSE", _wrap_XML_SCHEMAS_FACET_COLLAPSE, 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", _wrap_XML_SCHEMAS_QUALIF_ELEM, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_QUALIF_ATTR", _wrap_XML_SCHEMAS_QUALIF_ATTR, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_FINAL_DEFAULT_EXTENSION", _wrap_XML_SCHEMAS_FINAL_DEFAULT_EXTENSION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION", _wrap_XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_FINAL_DEFAULT_LIST", _wrap_XML_SCHEMAS_FINAL_DEFAULT_LIST, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_FINAL_DEFAULT_UNION", _wrap_XML_SCHEMAS_FINAL_DEFAULT_UNION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION", _wrap_XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION", _wrap_XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION", _wrap_XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMAS_INCLUDING_CONVERT_NS", _wrap_XML_SCHEMAS_INCLUDING_CONVERT_NS, 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", _wrap_XML_SCHEMA_WHITESPACE_UNKNOWN, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_WHITESPACE_PRESERVE", _wrap_XML_SCHEMA_WHITESPACE_PRESERVE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_WHITESPACE_REPLACE", _wrap_XML_SCHEMA_WHITESPACE_REPLACE, JS_veto_set_variable, context);
SWIGV8_AddStaticVariable(exports_obj, "XML_SCHEMA_WHITESPACE_COLLAPSE", _wrap_XML_SCHEMA_WHITESPACE_COLLAPSE, JS_veto_set_variable, context);
SWIGV8_AddMemberVariable(_exports__xmlLocationSet_class, "locNr", _wrap__xmlLocationSet_locNr_get, _wrap__xmlLocationSet_locNr_set);
SWIGV8_AddMemberVariable(_exports__xmlLocationSet_class, "locMax", _wrap__xmlLocationSet_locMax_get, _wrap__xmlLocationSet_locMax_set);
SWIGV8_AddMemberVariable(_exports__xmlLocationSet_class, "locTab", _wrap__xmlLocationSet_locTab_get, _wrap__xmlLocationSet_locTab_set);


  /* 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: _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: _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: _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: _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: _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: _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
/* Class: _xmlLocationSet (_exports__xmlLocationSet) */
SWIGV8_FUNCTION_TEMPLATE _exports__xmlLocationSet_class_0 = SWIGV8_CreateClassTemplate("_xmlLocationSet");
_exports__xmlLocationSet_class_0->SetCallHandler(_wrap_new__xmlLocationSet);
_exports__xmlLocationSet_class_0->Inherit(_exports__xmlLocationSet_class);
#if (SWIG_V8_VERSION < 0x0704)
_exports__xmlLocationSet_class_0->SetHiddenPrototype(true);
v8::Local<v8::Object> _exports__xmlLocationSet_obj = _exports__xmlLocationSet_class_0->GetFunction();
#else
v8::Local<v8::Object> _exports__xmlLocationSet_obj = _exports__xmlLocationSet_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, "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, "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, "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, "xmlExpFreeCtxt", _wrap_xmlExpFreeCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpNewCtxt", _wrap_xmlExpNewCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpCtxtNbNodes", _wrap_xmlExpCtxtNbNodes, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpCtxtNbCons", _wrap_xmlExpCtxtNbCons, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpFree", _wrap_xmlExpFree, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpRef", _wrap_xmlExpRef, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpParse", _wrap_xmlExpParse, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpNewAtom", _wrap_xmlExpNewAtom, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpNewOr", _wrap_xmlExpNewOr, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpNewSeq", _wrap_xmlExpNewSeq, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpNewRange", _wrap_xmlExpNewRange, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpIsNillable", _wrap_xmlExpIsNillable, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpMaxToken", _wrap_xmlExpMaxToken, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpGetLanguage", _wrap_xmlExpGetLanguage, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpGetStart", _wrap_xmlExpGetStart, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpStringDerive", _wrap_xmlExpStringDerive, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpExpDerive", _wrap_xmlExpExpDerive, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpSubsume", _wrap_xmlExpSubsume, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlExpDump", _wrap_xmlExpDump, 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, "xmlNewGlobalNs", _wrap_xmlNewGlobalNs, 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, "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, "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, "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, "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, "xmlHashAddEntry", _wrap_xmlHashAddEntry, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashUpdateEntry", _wrap_xmlHashUpdateEntry, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashAddEntry2", _wrap_xmlHashAddEntry2, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHashUpdateEntry2", _wrap_xmlHashUpdateEntry2, 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, "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, "xmlSetGenericErrorFunc", _wrap_xmlSetGenericErrorFunc, context);
SWIGV8_AddStaticFunction(exports_obj, "initGenericErrorDefaultFunc", _wrap_initGenericErrorDefaultFunc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSetStructuredErrorFunc", _wrap_xmlSetStructuredErrorFunc, 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, "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, "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, "xmlInitializePredefinedEntities", _wrap_xmlInitializePredefinedEntities, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNewEntity", _wrap_xmlNewEntity, 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, "xmlEncodeEntities", _wrap_xmlEncodeEntities, 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, "xmlCleanupPredefinedEntities", _wrap_xmlCleanupPredefinedEntities, 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, "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, "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, "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, "xmlSAX2InitDocbDefaultSAXHandler", _wrap_xmlSAX2InitDocbDefaultSAXHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "docbDefaultSAXHandlerInit", _wrap_docbDefaultSAXHandlerInit, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDefaultSAXHandlerInit", _wrap_xmlDefaultSAXHandlerInit, 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, "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, "xmlInitGlobals", _wrap_xmlInitGlobals, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCleanupGlobals", _wrap_xmlCleanupGlobals, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserInputBufferCreateFilenameDefault", _wrap_xmlParserInputBufferCreateFilenameDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlOutputBufferCreateFilenameDefault", _wrap_xmlOutputBufferCreateFilenameDefault, 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, "xmlGetGlobalState", _wrap_xmlGetGlobalState, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlInitializeGlobalState", _wrap_xmlInitializeGlobalState, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefSetGenericErrorFunc", _wrap_xmlThrDefSetGenericErrorFunc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefSetStructuredErrorFunc", _wrap_xmlThrDefSetStructuredErrorFunc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlRegisterNodeDefault", _wrap_xmlRegisterNodeDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefRegisterNodeDefault", _wrap_xmlThrDefRegisterNodeDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDeregisterNodeDefault", _wrap_xmlDeregisterNodeDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefDeregisterNodeDefault", _wrap_xmlThrDefDeregisterNodeDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefOutputBufferCreateFilenameDefault", _wrap_xmlThrDefOutputBufferCreateFilenameDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefParserInputBufferCreateFilenameDefault", _wrap_xmlThrDefParserInputBufferCreateFilenameDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "__docbDefaultSAXHandler", _wrap___docbDefaultSAXHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "__htmlDefaultSAXHandler", _wrap___htmlDefaultSAXHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlLastError", _wrap___xmlLastError, context);
SWIGV8_AddStaticFunction(exports_obj, "__oldXMLWDcompatibility", _wrap___oldXMLWDcompatibility, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlBufferAllocScheme", _wrap___xmlBufferAllocScheme, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefBufferAllocScheme", _wrap_xmlThrDefBufferAllocScheme, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlDefaultBufferSize", _wrap___xmlDefaultBufferSize, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefDefaultBufferSize", _wrap_xmlThrDefDefaultBufferSize, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlDefaultSAXHandler", _wrap___xmlDefaultSAXHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlDefaultSAXLocator", _wrap___xmlDefaultSAXLocator, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlDoValidityCheckingDefaultValue", _wrap___xmlDoValidityCheckingDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefDoValidityCheckingDefaultValue", _wrap_xmlThrDefDoValidityCheckingDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlGenericError", _wrap___xmlGenericError, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlStructuredError", _wrap___xmlStructuredError, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlGenericErrorContext", _wrap___xmlGenericErrorContext, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlStructuredErrorContext", _wrap___xmlStructuredErrorContext, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlGetWarningsDefaultValue", _wrap___xmlGetWarningsDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefGetWarningsDefaultValue", _wrap_xmlThrDefGetWarningsDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlIndentTreeOutput", _wrap___xmlIndentTreeOutput, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefIndentTreeOutput", _wrap_xmlThrDefIndentTreeOutput, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlTreeIndentString", _wrap___xmlTreeIndentString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefTreeIndentString", _wrap_xmlThrDefTreeIndentString, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlKeepBlanksDefaultValue", _wrap___xmlKeepBlanksDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefKeepBlanksDefaultValue", _wrap_xmlThrDefKeepBlanksDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlLineNumbersDefaultValue", _wrap___xmlLineNumbersDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefLineNumbersDefaultValue", _wrap_xmlThrDefLineNumbersDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlLoadExtDtdDefaultValue", _wrap___xmlLoadExtDtdDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefLoadExtDtdDefaultValue", _wrap_xmlThrDefLoadExtDtdDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlParserDebugEntities", _wrap___xmlParserDebugEntities, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefParserDebugEntities", _wrap_xmlThrDefParserDebugEntities, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlParserVersion", _wrap___xmlParserVersion, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlPedanticParserDefaultValue", _wrap___xmlPedanticParserDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefPedanticParserDefaultValue", _wrap_xmlThrDefPedanticParserDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlSaveNoEmptyTags", _wrap___xmlSaveNoEmptyTags, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefSaveNoEmptyTags", _wrap_xmlThrDefSaveNoEmptyTags, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlSubstituteEntitiesDefaultValue", _wrap___xmlSubstituteEntitiesDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlThrDefSubstituteEntitiesDefaultValue", _wrap_xmlThrDefSubstituteEntitiesDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlRegisterNodeDefaultValue", _wrap___xmlRegisterNodeDefaultValue, context);
SWIGV8_AddStaticFunction(exports_obj, "__xmlDeregisterNodeDefaultValue", _wrap___xmlDeregisterNodeDefaultValue, 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, "xmlInitParser", _wrap_xmlInitParser, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCleanupParser", _wrap_xmlCleanupParser, 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, "xmlKeepBlanksDefault", _wrap_xmlKeepBlanksDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlStopParser", _wrap_xmlStopParser, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlPedanticParserDefault", _wrap_xmlPedanticParserDefault, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlLineNumbersDefault", _wrap_xmlLineNumbersDefault, 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, "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, "xmlGetFeaturesList", _wrap_xmlGetFeaturesList, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlGetFeature", _wrap_xmlGetFeature, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSetFeature", _wrap_xmlSetFeature, 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, "xmlCtxtUseOptions", _wrap_xmlCtxtUseOptions, 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, "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, "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, "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, "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, "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, "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, "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, "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, "xmlSwitchEncoding", _wrap_xmlSwitchEncoding, 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, "htmlInitAutoClose", _wrap_htmlInitAutoClose, context);
SWIGV8_AddStaticFunction(exports_obj, "htmlCreateFileParserCtxt", _wrap_htmlCreateFileParserCtxt, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSetEntityReferenceFunc", _wrap_xmlSetEntityReferenceFunc, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseQuotedString", _wrap_xmlParseQuotedString, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseNamespace", _wrap_xmlParseNamespace, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNamespaceParseNSDef", _wrap_xmlNamespaceParseNSDef, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlScanName", _wrap_xmlScanName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNamespaceParseNCName", _wrap_xmlNamespaceParseNCName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParserHandleReference", _wrap_xmlParserHandleReference, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlNamespaceParseQName", _wrap_xmlNamespaceParseQName, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlDecodeEntities", _wrap_xmlDecodeEntities, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlHandleEntity", _wrap_xmlHandleEntity, 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, "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, "getPublicId", _wrap_getPublicId, context);
SWIGV8_AddStaticFunction(exports_obj, "getSystemId", _wrap_getSystemId, context);
SWIGV8_AddStaticFunction(exports_obj, "setDocumentLocator", _wrap_setDocumentLocator, context);
SWIGV8_AddStaticFunction(exports_obj, "getLineNumber", _wrap_getLineNumber, context);
SWIGV8_AddStaticFunction(exports_obj, "getColumnNumber", _wrap_getColumnNumber, context);
SWIGV8_AddStaticFunction(exports_obj, "isStandalone", _wrap_isStandalone, context);
SWIGV8_AddStaticFunction(exports_obj, "hasInternalSubset", _wrap_hasInternalSubset, context);
SWIGV8_AddStaticFunction(exports_obj, "hasExternalSubset", _wrap_hasExternalSubset, context);
SWIGV8_AddStaticFunction(exports_obj, "internalSubset", _wrap_internalSubset, context);
SWIGV8_AddStaticFunction(exports_obj, "externalSubset", _wrap_externalSubset, context);
SWIGV8_AddStaticFunction(exports_obj, "getEntity", _wrap_getEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "getParameterEntity", _wrap_getParameterEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "resolveEntity", _wrap_resolveEntity, context);
SWIGV8_AddStaticFunction(exports_obj, "entityDecl", _wrap_entityDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "attributeDecl", _wrap_attributeDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "elementDecl", _wrap_elementDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "notationDecl", _wrap_notationDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "unparsedEntityDecl", _wrap_unparsedEntityDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "startDocument", _wrap_startDocument, context);
SWIGV8_AddStaticFunction(exports_obj, "endDocument", _wrap_endDocument, context);
SWIGV8_AddStaticFunction(exports_obj, "attribute", _wrap_attribute, context);
SWIGV8_AddStaticFunction(exports_obj, "startElement", _wrap_startElement, context);
SWIGV8_AddStaticFunction(exports_obj, "endElement", _wrap_endElement, context);
SWIGV8_AddStaticFunction(exports_obj, "reference", _wrap_reference, context);
SWIGV8_AddStaticFunction(exports_obj, "characters", _wrap_characters, context);
SWIGV8_AddStaticFunction(exports_obj, "ignorableWhitespace", _wrap_ignorableWhitespace, context);
SWIGV8_AddStaticFunction(exports_obj, "processingInstruction", _wrap_processingInstruction, context);
SWIGV8_AddStaticFunction(exports_obj, "globalNamespace", _wrap_globalNamespace, context);
SWIGV8_AddStaticFunction(exports_obj, "setNamespace", _wrap_setNamespace, context);
SWIGV8_AddStaticFunction(exports_obj, "getNamespace", _wrap_getNamespace, context);
SWIGV8_AddStaticFunction(exports_obj, "checkNamespace", _wrap_checkNamespace, context);
SWIGV8_AddStaticFunction(exports_obj, "namespaceDecl", _wrap_namespaceDecl, context);
SWIGV8_AddStaticFunction(exports_obj, "comment", _wrap_comment, context);
SWIGV8_AddStaticFunction(exports_obj, "cdataBlock", _wrap_cdataBlock, context);
SWIGV8_AddStaticFunction(exports_obj, "initxmlDefaultSAXHandler", _wrap_initxmlDefaultSAXHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "inithtmlDefaultSAXHandler", _wrap_inithtmlDefaultSAXHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "initdocbDefaultSAXHandler", _wrap_initdocbDefaultSAXHandler, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlCreateURI", _wrap_xmlCreateURI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBuildURI", _wrap_xmlBuildURI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlBuildRelativeURI", _wrap_xmlBuildRelativeURI, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlParseURI", _wrap_xmlParseURI, 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, "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, "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, "xmlSaveSetEscape", _wrap_xmlSaveSetEscape, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlSaveSetAttrEscape", _wrap_xmlSaveSetAttrEscape, 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, "xmlXPtrLocationSetCreate", _wrap_xmlXPtrLocationSetCreate, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrFreeLocationSet", _wrap_xmlXPtrFreeLocationSet, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrLocationSetMerge", _wrap_xmlXPtrLocationSetMerge, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrNewRange", _wrap_xmlXPtrNewRange, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrNewRangePoints", _wrap_xmlXPtrNewRangePoints, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrNewRangeNodePoint", _wrap_xmlXPtrNewRangeNodePoint, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrNewRangePointNode", _wrap_xmlXPtrNewRangePointNode, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrNewRangeNodes", _wrap_xmlXPtrNewRangeNodes, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrNewLocationSetNodes", _wrap_xmlXPtrNewLocationSetNodes, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrNewLocationSetNodeSet", _wrap_xmlXPtrNewLocationSetNodeSet, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrNewRangeNodeObject", _wrap_xmlXPtrNewRangeNodeObject, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrNewCollapsedRange", _wrap_xmlXPtrNewCollapsedRange, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrLocationSetAdd", _wrap_xmlXPtrLocationSetAdd, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrWrapLocationSet", _wrap_xmlXPtrWrapLocationSet, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrLocationSetDel", _wrap_xmlXPtrLocationSetDel, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrLocationSetRemove", _wrap_xmlXPtrLocationSetRemove, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrNewContext", _wrap_xmlXPtrNewContext, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrEval", _wrap_xmlXPtrEval, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrRangeToFunction", _wrap_xmlXPtrRangeToFunction, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrBuildNodeList", _wrap_xmlXPtrBuildNodeList, context);
SWIGV8_AddStaticFunction(exports_obj, "xmlXPtrEvalRangePredicate", _wrap_xmlXPtrEvalRangePredicate, 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("_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("_xmlCharEncodingHandler"), _exports__xmlCharEncodingHandler_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("_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("_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("_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));
SWIGV8_MAYBE_CHECK(exports_obj->Set(context, SWIGV8_SYMBOL_NEW("_xmlLocationSet"), _exports__xmlLocationSet_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
