Major Refactoring v2.0

4 files changed, 9233 insertions, 262 deletions

diff --git a/src/uscxml/plugins/datamodel/lua/LuaDOM.cpp.inc b/src/uscxml/plugins/datamodel/lua/LuaDOM.cpp.inc
new file mode 100644
index 0000000..5a256b6
--- /dev/null
+++ b/src/uscxml/plugins/datamodel/lua/LuaDOM.cpp.inc
@@ -0,0 +1,8969 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.8
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGLUA
+#define SWIGLUA
+#endif
+
+#define SWIG_LUA_TARGET SWIG_LUA_FLAVOR_LUA
+#define SWIG_LUA_MODULE_GLOBAL
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  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 (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#  ifndef GCC_HASCLASSVISIBILITY
+#    define GCC_HASCLASSVISIBILITY
+#  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
+
+/* -----------------------------------------------------------------------------
+ * 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
+
+/* 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 to return 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)
+#define SWIG_ERROR                 (-1)
+#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 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(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.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  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 = ((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = ((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   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
+
+/* -----------------------------------------------------------------------------
+ * luarun.swg
+ *
+ * This file contains the runtime support for Lua modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lua.h"
+#include "lauxlib.h"
+#include <stdlib.h>  /* for malloc */
+#include <assert.h>  /* for a few sanity tests */
+
+/* -----------------------------------------------------------------------------
+ * Lua flavors
+ * ----------------------------------------------------------------------------- */
+
+#define SWIG_LUA_FLAVOR_LUA 1
+#define SWIG_LUA_FLAVOR_ELUA 2
+#define SWIG_LUA_FLAVOR_ELUAC 3
+
+#if !defined(SWIG_LUA_TARGET)
+# error SWIG_LUA_TARGET not defined
+#endif
+
+#if defined(SWIG_LUA_ELUA_EMULATE)
+
+struct swig_elua_entry;
+
+typedef struct swig_elua_key {
+  int type;
+  union {
+    const char* strkey;
+    lua_Number numkey;
+  } key;
+} swig_elua_key;
+
+typedef struct swig_elua_val {
+  int type;
+  union {
+    lua_Number number;
+    const struct swig_elua_entry *table;
+    const char *string;
+    lua_CFunction function;
+    struct {
+      char member;
+      long lvalue;
+      void *pvalue;
+      swig_type_info **ptype;
+    } userdata;
+  } value;
+} swig_elua_val;
+
+typedef struct swig_elua_entry {
+  swig_elua_key key;
+  swig_elua_val value;
+} swig_elua_entry;
+
+#define LSTRKEY(x) {LUA_TSTRING, {.strkey = x} }
+#define LNUMKEY(x) {LUA_TNUMBER, {.numkey = x} }
+#define LNILKEY {LUA_TNIL, {.strkey = 0} }
+
+#define LNUMVAL(x) {LUA_TNUMBER, {.number = x} }
+#define LFUNCVAL(x) {LUA_TFUNCTION, {.function = x} }
+#define LROVAL(x) {LUA_TTABLE, {.table = x} }
+#define LNILVAL {LUA_TNIL, {.string = 0} }
+#define LSTRVAL(x) {LUA_TSTRING, {.string = x} }
+
+#define LUA_REG_TYPE swig_elua_entry
+
+#define SWIG_LUA_ELUA_EMUL_METATABLE_KEY "__metatable"
+
+#define lua_pushrotable(L,p)\
+  lua_newtable(L);\
+  assert(p);\
+  SWIG_Lua_elua_emulate_register(L,(swig_elua_entry*)(p));
+
+#define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\
+  LSTRKEY(B), {LUA_TUSERDATA, { .userdata={0,0,(void*)(C),&D} } }
+
+#define SWIG_LUA_CONSTTAB_BINARY(B,S,C,D)\
+  LSTRKEY(B), {LUA_TUSERDATA, { .userdata={1,S,(void*)(C),&D} } }
+#endif
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
+#  define SWIG_LUA_CONSTTAB_INT(B, C) LSTRKEY(B), LNUMVAL(C)
+#  define SWIG_LUA_CONSTTAB_FLOAT(B, C) LSTRKEY(B), LNUMVAL(C)
+#  define SWIG_LUA_CONSTTAB_STRING(B, C) LSTRKEY(B), LSTRVAL(C)
+#  define SWIG_LUA_CONSTTAB_CHAR(B, C) LSTRKEY(B), LNUMVAL(C)
+    /* Those two types of constants are not supported in elua */
+
+#ifndef SWIG_LUA_CONSTTAB_POINTER
+#warning eLua does not support pointers as constants. By default, nil will be used as value
+#define SWIG_LUA_CONSTTAB_POINTER(B,C,D) LSTRKEY(B), LNILVAL
+#endif
+
+#ifndef SWIG_LUA_CONSTTAB_BINARY
+#warning eLua does not support pointers to member as constants. By default, nil will be used as value
+#define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D) LSTRKEY(B), LNILVAL
+#endif
+#else /* SWIG_LUA_FLAVOR_LUA */
+#  define SWIG_LUA_CONSTTAB_INT(B, C) SWIG_LUA_INT, (char *)B, (long)C, 0, 0, 0
+#  define SWIG_LUA_CONSTTAB_FLOAT(B, C) SWIG_LUA_FLOAT, (char *)B, 0, (double)C, 0, 0
+#  define SWIG_LUA_CONSTTAB_STRING(B, C) SWIG_LUA_STRING, (char *)B, 0, 0, (void *)C, 0
+#  define SWIG_LUA_CONSTTAB_CHAR(B, C) SWIG_LUA_CHAR, (char *)B, (long)C, 0, 0, 0
+#  define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\
+       SWIG_LUA_POINTER, (char *)B, 0, 0, (void *)C, &D
+#  define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D)\
+       SWIG_LUA_BINARY,  (char *)B, S, 0, (void *)C, &D
+#endif
+
+#ifndef SWIG_LUA_ELUA_EMULATE
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
+#  define LRO_STRVAL(v) {{.p = (char *) v}, LUA_TSTRING}
+#  define LSTRVAL LRO_STRVAL
+#endif
+#endif /* SWIG_LUA_ELUA_EMULATE*/
+
+#ifndef SWIG_LUA_ELUA_EMULATE
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
+
+#ifndef MIN_OPT_LEVEL
+#define MIN_OPT_LEVEL 2
+#endif
+
+#include "lrodefs.h"
+#include "lrotable.h"
+#endif
+#endif /* SWIG_LUA_ELUA_EMULATE*/
+/* -----------------------------------------------------------------------------
+ * compatibility defines
+ * ----------------------------------------------------------------------------- */
+
+/* History of Lua C API length functions:  In Lua 5.0 (and before?)
+   there was "lua_strlen".  In Lua 5.1, this was renamed "lua_objlen",
+   but a compatibility define of "lua_strlen" was added.  In Lua 5.2,
+   this function was again renamed, to "lua_rawlen" (to emphasize that
+   it doesn't call the "__len" metamethod), and the compatibility
+   define of lua_strlen was removed.  All SWIG uses have been updated
+   to "lua_rawlen", and we add our own defines of that here for older
+   versions of Lua.  */
+#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501
+# define lua_rawlen lua_strlen
+#elif LUA_VERSION_NUM == 501
+# define lua_rawlen lua_objlen
+#endif
+
+
+/* lua_pushglobaltable is the recommended "future-proof" way to get
+   the global table for Lua 5.2 and later.  Here we define
+   lua_pushglobaltable ourselves for Lua versions before 5.2.  */
+#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
+# define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX)
+#endif
+
+/* lua_absindex was introduced in Lua 5.2 */
+#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
+# define lua_absindex(L,i) ((i)>0 || (i) <= LUA_REGISTRYINDEX ? (i) : lua_gettop(L) + (i) + 1)
+#endif
+
+/* lua_rawsetp was introduced in Lua 5.2 */
+#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
+#define lua_rawsetp(L,index,ptr)\
+  lua_pushlightuserdata(L,(void*)(ptr));\
+  lua_insert(L,-2);\
+  lua_rawset(L,index);
+
+#define lua_rawgetp(L,index,ptr)\
+  lua_pushlightuserdata(L,(void*)(ptr));\
+  lua_rawget(L,index);
+
+#endif
+
+/* --------------------------------------------------------------------------
+ * Helper functions for error handling
+ * -------------------------------------------------------------------------- */
+
+/* Push the string STR on the Lua stack, like lua_pushstring, but
+   prefixed with the the location of the innermost Lua call-point
+   (as formated by luaL_where).  */
+SWIGRUNTIME void
+SWIG_Lua_pusherrstring (lua_State *L, const char *str)
+{
+  luaL_where (L, 1);
+  lua_pushstring (L, str);
+  lua_concat (L, 2);
+}
+
+/* Push a formatted string generated from FMT and following args on
+   the Lua stack, like lua_pushfstring, but prefixed with the the
+   location of the innermost Lua call-point (as formated by luaL_where).  */
+SWIGRUNTIME void
+SWIG_Lua_pushferrstring (lua_State *L, const char *fmt, ...)
+{
+  va_list argp;
+  va_start(argp, fmt);
+  luaL_where(L, 1);
+  lua_pushvfstring(L, fmt, argp);
+  va_end(argp);
+  lua_concat(L, 2);
+}
+
+
+/* -----------------------------------------------------------------------------
+ * global swig types
+ * ----------------------------------------------------------------------------- */
+/* Constant table */
+#define SWIG_LUA_INT     1
+#define SWIG_LUA_FLOAT   2
+#define SWIG_LUA_STRING  3
+#define SWIG_LUA_POINTER 4
+#define SWIG_LUA_BINARY  5
+#define SWIG_LUA_CHAR    6
+
+/* Structure for variable linking table */
+typedef struct {
+  const char *name;
+  lua_CFunction get;
+  lua_CFunction set;
+} swig_lua_var_info;
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
+typedef const LUA_REG_TYPE swig_lua_method;
+typedef const LUA_REG_TYPE swig_lua_const_info;
+#else /* Normal lua */
+typedef luaL_Reg swig_lua_method;
+
+/* Constant information structure */
+typedef struct {
+    int type;
+    char *name;
+    long lvalue;
+    double dvalue;
+    void   *pvalue;
+    swig_type_info **ptype;
+} swig_lua_const_info;
+
+#endif
+
+typedef struct {
+  const char     *name;
+  lua_CFunction   getmethod;
+  lua_CFunction   setmethod;
+} swig_lua_attribute;
+
+
+struct swig_lua_class;
+/* Can be used to create namespaces. Currently used to wrap class static methods/variables/constants */
+typedef struct swig_lua_namespace {
+  const char            *name;
+  swig_lua_method       *ns_methods;
+  swig_lua_attribute    *ns_attributes;
+  swig_lua_const_info   *ns_constants;
+  struct swig_lua_class        **ns_classes;
+  struct swig_lua_namespace    **ns_namespaces;
+} swig_lua_namespace;
+
+typedef struct swig_lua_class {
+  const char    *name; /* Name that this class has in Lua */
+  const char    *fqname; /* Fully qualified name - Scope + class name */
+  swig_type_info   **type;
+  lua_CFunction  constructor;
+  void    (*destructor)(void *);
+  swig_lua_method   *methods;
+  swig_lua_attribute     *attributes;
+  swig_lua_namespace    *cls_static;
+  swig_lua_method   *metatable; /* 0 for -eluac */
+  struct swig_lua_class **bases;
+  const char **base_names;
+} swig_lua_class;
+
+/* this is the struct for wrapping all pointers in SwigLua
+*/
+typedef struct {
+  swig_type_info   *type;
+  int     own;  /* 1 if owned & must be destroyed */
+  void        *ptr;
+} swig_lua_userdata;
+
+/* this is the struct for wrapping arbitrary packed binary data
+(currently it is only used for member function pointers)
+the data ordering is similar to swig_lua_userdata, but it is currently not possible
+to tell the two structures apart within SWIG, other than by looking at the type
+*/
+typedef struct {
+  swig_type_info   *type;
+  int     own;  /* 1 if owned & must be destroyed */
+  char data[1];       /* arbitary amount of data */    
+} swig_lua_rawdata;
+
+/* Common SWIG API */
+#define SWIG_NewPointerObj(L, ptr, type, owner)       SWIG_Lua_NewPointerObj(L, (void *)ptr, type, owner)
+#define SWIG_ConvertPtr(L,idx, ptr, type, flags)    SWIG_Lua_ConvertPtr(L,idx,ptr,type,flags)
+#define SWIG_MustGetPtr(L,idx, type,flags, argnum,fnname)  SWIG_Lua_MustGetPtr(L,idx, type,flags, argnum,fnname)
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(L, idx, ptr, sz, ty)       SWIG_Lua_ConvertPacked(L, idx, ptr, sz, ty)
+#define SWIG_NewMemberObj(L, ptr, sz, type)      SWIG_Lua_NewPackedObj(L, ptr, sz, type)
+
+/* Runtime API */
+#define SWIG_GetModule(clientdata) SWIG_Lua_GetModule((lua_State*)(clientdata))
+#define SWIG_SetModule(clientdata, pointer) SWIG_Lua_SetModule((lua_State*) (clientdata), pointer)
+#define SWIG_MODULE_CLIENTDATA_TYPE lua_State*
+
+/* Contract support */
+#define SWIG_contract_assert(expr, msg)  \
+  if (!(expr)) { SWIG_Lua_pusherrstring(L, (char *) msg); goto fail; } else
+
+
+/* helper #defines */
+#define SWIG_fail {goto fail;}
+#define SWIG_fail_arg(func_name,argnum,type) \
+  {SWIG_Lua_pushferrstring(L,"Error in %s (arg %d), expected '%s' got '%s'",\
+  func_name,argnum,type,SWIG_Lua_typename(L,argnum));\
+  goto fail;}
+#define SWIG_fail_ptr(func_name,argnum,type) \
+  SWIG_fail_arg(func_name,argnum,(type && type->str)?type->str:"void*")
+#define SWIG_check_num_args(func_name,a,b) \
+  if (lua_gettop(L)<a || lua_gettop(L)>b) \
+  {SWIG_Lua_pushferrstring(L,"Error in %s expected %d..%d args, got %d",func_name,a,b,lua_gettop(L));\
+  goto fail;}
+
+
+#define SWIG_Lua_get_table(L,n) \
+  (lua_pushstring(L, n), lua_rawget(L,-2))
+
+#define SWIG_Lua_add_function(L,n,f) \
+  (lua_pushstring(L, n), \
+      lua_pushcfunction(L, f), \
+      lua_rawset(L,-3))
+
+#define SWIG_Lua_add_boolean(L,n,b) \
+  (lua_pushstring(L, n), \
+      lua_pushboolean(L, b), \
+      lua_rawset(L,-3))
+
+/* special helper for allowing 'nil' for usertypes */
+#define SWIG_isptrtype(L,I) (lua_isuserdata(L,I) || lua_isnil(L,I))
+
+#ifdef __cplusplus
+/* Special helper for member function pointers 
+it gets the address, casts it, then dereferences it */
+/*#define SWIG_mem_fn_as_voidptr(a)  (*((char**)&(a))) */
+#endif
+
+/* storing/access of swig_module_info */
+SWIGRUNTIME swig_module_info *
+SWIG_Lua_GetModule(lua_State *L) {
+  swig_module_info *ret = 0;
+  lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  lua_rawget(L,LUA_REGISTRYINDEX);
+  if (lua_islightuserdata(L,-1))
+    ret=(swig_module_info*)lua_touserdata(L,-1);
+  lua_pop(L,1);  /* tidy */
+  return ret;
+}
+
+SWIGRUNTIME void
+SWIG_Lua_SetModule(lua_State *L, swig_module_info *module) {
+  /* add this all into the Lua registry: */
+  lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  lua_pushlightuserdata(L,(void*)module);
+  lua_rawset(L,LUA_REGISTRYINDEX);
+}
+
+/* -----------------------------------------------------------------------------
+ * global variable support code: modules
+ * ----------------------------------------------------------------------------- */
+
+/* this function is called when trying to set an immutable.
+default action is to print an error.
+This can removed with a compile flag SWIGLUA_IGNORE_SET_IMMUTABLE */
+SWIGINTERN int SWIG_Lua_set_immutable(lua_State *L)
+{
+/*  there should be 1 param passed in: the new value */
+#ifndef SWIGLUA_IGNORE_SET_IMMUTABLE
+  lua_pop(L,1);  /* remove it */
+  luaL_error(L,"This variable is immutable");
+#endif
+    return 0;   /* should not return anything */
+}
+
+#ifdef SWIG_LUA_ELUA_EMULATE
+
+SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own);
+SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type);
+static int swig_lua_elua_emulate_unique_key;
+
+/* This function emulates eLua rotables behaviour. It loads a rotable definition into the usual lua table. */
+SWIGINTERN void SWIG_Lua_elua_emulate_register(lua_State *L, const swig_elua_entry *table)
+{
+  int i, table_parsed, parsed_tables_array, target_table;
+  assert(lua_istable(L,-1));
+  target_table = lua_gettop(L);
+  /* Get the registry where we put all parsed tables to avoid loops */
+  lua_rawgetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key);
+  if(lua_isnil(L,-1)) {
+    lua_pop(L,1);
+    lua_newtable(L);
+    lua_pushvalue(L,-1);
+    lua_rawsetp(L,LUA_REGISTRYINDEX,(void*)(&swig_lua_elua_emulate_unique_key));
+  }
+  parsed_tables_array = lua_gettop(L);
+  lua_pushvalue(L,target_table);
+  lua_rawsetp(L, parsed_tables_array, table);
+  table_parsed = 0;
+  const int SWIGUNUSED pairs_start = lua_gettop(L);
+  for(i = 0;table[i].key.type != LUA_TNIL || table[i].value.type != LUA_TNIL;i++)
+  {
+    const swig_elua_entry *entry = table + i;
+    int is_metatable = 0;
+    switch(entry->key.type) {
+      case LUA_TSTRING:
+        lua_pushstring(L,entry->key.key.strkey);
+        if(strcmp(entry->key.key.strkey, SWIG_LUA_ELUA_EMUL_METATABLE_KEY) == 0)
+          is_metatable = 1;
+        break;
+      case  LUA_TNUMBER:
+        lua_pushnumber(L,entry->key.key.numkey);
+        break;
+      case LUA_TNIL:
+        lua_pushnil(L);
+        break;
+      default:
+        assert(0);
+    }
+    switch(entry->value.type) {
+      case LUA_TSTRING:
+        lua_pushstring(L,entry->value.value.string);
+        break;
+      case  LUA_TNUMBER:
+        lua_pushnumber(L,entry->value.value.number);
+        break;
+      case LUA_TFUNCTION:
+        lua_pushcfunction(L,entry->value.value.function);
+        break;
+      case LUA_TTABLE:
+        lua_rawgetp(L,parsed_tables_array, entry->value.value.table);
+        table_parsed = !lua_isnil(L,-1);
+        if(!table_parsed) {
+          lua_pop(L,1); /*remove nil */
+          lua_newtable(L);
+          SWIG_Lua_elua_emulate_register(L,entry->value.value.table);
+        } 
+        if(is_metatable) {
+          assert(lua_istable(L,-1));
+          lua_pushvalue(L,-1);
+          lua_setmetatable(L,target_table);
+        }
+
+        break;
+      case LUA_TUSERDATA:
+        if(entry->value.value.userdata.member) 
+          SWIG_NewMemberObj(L,entry->value.value.userdata.pvalue,
+              entry->value.value.userdata.lvalue,
+              *(entry->value.value.userdata.ptype));
+        else 
+          SWIG_NewPointerObj(L,entry->value.value.userdata.pvalue,
+              *(entry->value.value.userdata.ptype),0);
+        break;
+      case LUA_TNIL:
+        lua_pushnil(L);
+        break;
+      default:
+        assert(0);
+    }
+    assert(lua_gettop(L) == pairs_start + 2);
+    lua_rawset(L,target_table);
+  }
+  lua_pop(L,1); /* Removing parsed tables storage */
+  assert(lua_gettop(L) == target_table);
+}
+
+SWIGINTERN void SWIG_Lua_elua_emulate_register_clear(lua_State *L)
+{
+  lua_pushnil(L);
+  lua_rawsetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key);
+}
+
+SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L);
+
+SWIGINTERN int SWIG_Lua_emulate_elua_getmetatable(lua_State *L)
+{
+  SWIG_check_num_args("getmetatable(SWIG eLua emulation)", 1, 1);
+  SWIG_Lua_get_class_registry(L);
+  lua_getfield(L,-1,"lua_getmetatable");
+  lua_remove(L,-2); /* remove the registry*/
+  assert(!lua_isnil(L,-1));
+  lua_pushvalue(L,1);
+  assert(lua_gettop(L) == 3); /* object | function | object again */
+  lua_call(L,1,1);
+  if(!lua_isnil(L,-1)) /*There is an ordinary metatable */
+    return 1;
+  /*if it is a table, then emulate elua behaviour - check for __metatable attribute of a table*/
+  assert(lua_gettop(L) == 2);
+  if(lua_istable(L,-2)) {
+    lua_pop(L,1); /*remove the nil*/
+    lua_getfield(L,-1, SWIG_LUA_ELUA_EMUL_METATABLE_KEY);
+  }
+  assert(lua_gettop(L) == 2);
+  return 1;
+  
+fail:
+  lua_error(L);
+  return 0;
+}
+
+SWIGINTERN void SWIG_Lua_emulate_elua_swap_getmetatable(lua_State *L)
+{
+  SWIG_Lua_get_class_registry(L);
+  lua_pushglobaltable(L);
+  lua_pushstring(L,"lua_getmetatable");
+  lua_getfield(L,-2,"getmetatable");
+  assert(!lua_isnil(L,-1));
+  lua_rawset(L,-4);
+  lua_pushstring(L, "getmetatable");
+  lua_pushcfunction(L, SWIG_Lua_emulate_elua_getmetatable);
+  lua_rawset(L,-3);
+  lua_pop(L,2);
+      
+}
+/* END OF REMOVE */
+
+#endif
+/* -----------------------------------------------------------------------------
+ * global variable support code: namespaces and modules (which are the same thing)
+ * ----------------------------------------------------------------------------- */
+
+SWIGINTERN int SWIG_Lua_namespace_get(lua_State *L)
+{
+/*  there should be 2 params passed in
+  (1) table (not the meta table)
+  (2) string name of the attribute
+*/
+  assert(lua_istable(L,-2));  /* just in case */
+  lua_getmetatable(L,-2);
+  assert(lua_istable(L,-1));
+  SWIG_Lua_get_table(L,".get"); /* find the .get table */
+  assert(lua_istable(L,-1));
+  /* look for the key in the .get table */
+  lua_pushvalue(L,2);  /* key */
+  lua_rawget(L,-2);
+  lua_remove(L,-2); /* stack tidy, remove .get table */
+  if (lua_iscfunction(L,-1))
+  {  /* found it so call the fn & return its value */
+    lua_call(L,0,1);  /* 1 value in (userdata),1 out (result) */
+    lua_remove(L,-2); /* stack tidy, remove metatable */
+    return 1;
+  }
+  lua_pop(L,1);  /* remove whatever was there */
+  /* ok, so try the .fn table */
+  SWIG_Lua_get_table(L,".fn"); /* find the .get table */
+  assert(lua_istable(L,-1));  /* just in case */
+  lua_pushvalue(L,2);  /* key */
+  lua_rawget(L,-2);  /* look for the fn */
+  lua_remove(L,-2); /* stack tidy, remove .fn table */
+  if (lua_isfunction(L,-1)) /* note: whether it's a C function or lua function */
+  {  /* found it so return the fn & let lua call it */
+    lua_remove(L,-2); /* stack tidy, remove metatable */
+    return 1;
+  }
+  lua_pop(L,1);  /* remove whatever was there */
+  return 0;
+}
+
+SWIGINTERN int SWIG_Lua_namespace_set(lua_State *L)
+{
+/*  there should be 3 params passed in
+  (1) table (not the meta table)
+  (2) string name of the attribute
+  (3) any for the new value
+*/
+
+  assert(lua_istable(L,1));
+  lua_getmetatable(L,1);    /* get the meta table */
+  assert(lua_istable(L,-1));
+
+  SWIG_Lua_get_table(L,".set"); /* find the .set table */
+  if (lua_istable(L,-1))
+  {
+    /* look for the key in the .set table */
+    lua_pushvalue(L,2);  /* key */
+    lua_rawget(L,-2);
+    if (lua_iscfunction(L,-1))
+    {  /* found it so call the fn & return its value */
+      lua_pushvalue(L,3);  /* value */
+      lua_call(L,1,0);
+      return 0;
+    }
+    lua_pop(L,1);  /* remove the value */
+  }
+  lua_pop(L,1);  /* remove the value .set table */
+  lua_pop(L,1); /* remote metatable */
+  lua_rawset(L,-3);
+  return 0;
+}
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */
+SWIGINTERN void SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]); /* forward declaration */
+SWIGINTERN void  SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn); /* forward declaration */
+SWIGINTERN void  SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss);
+
+/* helper function - register namespace methods and attributes into namespace */
+SWIGINTERN int SWIG_Lua_add_namespace_details(lua_State *L, swig_lua_namespace *ns)
+{
+  int i;
+  /* There must be namespace table (not metatable) at the top of the stack */
+  assert(lua_istable(L,-1));
+  SWIG_Lua_InstallConstants(L, ns->ns_constants);
+
+  /* add methods to the namespace/module table */
+  for(i=0;ns->ns_methods[i].name;i++){
+    SWIG_Lua_add_function(L,ns->ns_methods[i].name,ns->ns_methods[i].func);
+  }
+  lua_getmetatable(L,-1);
+
+  /* add fns */
+  for(i=0;ns->ns_attributes[i].name;i++){
+    SWIG_Lua_add_variable(L,ns->ns_attributes[i].name,ns->ns_attributes[i].getmethod,ns->ns_attributes[i].setmethod);
+  }
+
+  /* clear stack - remove metatble */
+  lua_pop(L,1);
+  return 0;
+}
+
+/* Register all classes in the namespace */
+SWIGINTERN void SWIG_Lua_add_namespace_classes(lua_State *L, swig_lua_namespace *ns)
+{
+  swig_lua_class **classes;
+
+  /* There must be a module/namespace table at the top of the stack */
+  assert(lua_istable(L,-1));
+
+  classes = ns->ns_classes;
+
+  if( classes != 0 ) {
+    while(*classes != 0) {
+      SWIG_Lua_class_register(L, *classes);
+      classes++;
+    }
+  }
+}
+
+/* Helper function. Creates namespace table and adds it to module table
+   if 'reg' is true, then will register namespace table to parent one (must be on top of the stack
+   when function is called).
+   Function always returns newly registered table on top of the stack.
+*/
+SWIGINTERN void SWIG_Lua_namespace_register(lua_State *L, swig_lua_namespace *ns, int reg)
+{
+  swig_lua_namespace **sub_namespace;
+  /* 1 argument - table on the top of the stack */
+  const int SWIGUNUSED begin = lua_gettop(L);
+  assert(lua_istable(L,-1)); /* just in case. This is supposed to be module table or parent namespace table */
+  lua_checkstack(L,5);
+  lua_newtable(L); /* namespace itself */
+  lua_newtable(L); /* metatable for namespace */
+
+  /* add a table called ".get" */
+  lua_pushstring(L,".get");
+  lua_newtable(L);
+  lua_rawset(L,-3);
+  /* add a table called ".set" */
+  lua_pushstring(L,".set");
+  lua_newtable(L);
+  lua_rawset(L,-3);
+  /* add a table called ".fn" */
+  lua_pushstring(L,".fn");
+  lua_newtable(L);
+  lua_rawset(L,-3);
+
+  /* add accessor fns for using the .get,.set&.fn */
+  SWIG_Lua_add_function(L,"__index",SWIG_Lua_namespace_get);
+  SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_namespace_set);
+
+  lua_setmetatable(L,-2); /* set metatable */
+
+  /* Register all functions, variables etc */
+  SWIG_Lua_add_namespace_details(L,ns);
+  /* Register classes */
+  SWIG_Lua_add_namespace_classes(L,ns);
+
+  sub_namespace = ns->ns_namespaces;
+  if( sub_namespace != 0) {
+    while(*sub_namespace != 0) {
+      SWIG_Lua_namespace_register(L, *sub_namespace, 1);
+      lua_pop(L,1); /* removing sub-namespace table */
+      sub_namespace++;
+    }
+  }
+
+  if (reg) {
+    lua_pushstring(L,ns->name);
+    lua_pushvalue(L,-2);
+    lua_rawset(L,-4); /* add namespace to module table */
+  }
+  assert(lua_gettop(L) == begin+1);
+}
+#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */
+
+/* -----------------------------------------------------------------------------
+ * global variable support code: classes
+ * ----------------------------------------------------------------------------- */
+
+SWIGINTERN void  SWIG_Lua_get_class_metatable(lua_State *L,const char *cname);
+
+typedef int (*swig_lua_base_iterator_func)(lua_State*,swig_type_info*, int, int *ret);
+
+SWIGINTERN int SWIG_Lua_iterate_bases(lua_State *L, swig_type_info * SWIGUNUSED swig_type,
+  int first_arg, swig_lua_base_iterator_func func, int  *const ret)
+{
+    /* first_arg - position of the object in stack. Everything that is above are arguments
+     * and is passed to every evocation of the func */
+    int last_arg = lua_gettop(L);/* position of last argument */
+    int original_metatable = last_arg + 1;
+    size_t bases_count;
+    int result = SWIG_ERROR;
+    int bases_table;
+    (void)swig_type;
+    lua_getmetatable(L,first_arg);
+
+    /* initialise base search */
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
+    SWIG_Lua_get_table(L,".bases");
+    assert(lua_istable(L,-1));
+    bases_count = lua_rawlen(L,-1);
+    bases_table = lua_gettop(L);
+#else
+    /* In elua .bases table doesn't exist. Use table from swig_lua_class */
+    (void)bases_table;
+    assert(swig_type!=0);
+    swig_module_info *module=SWIG_GetModule(L);
+    swig_lua_class **bases= ((swig_lua_class*)(swig_type->clientdata))->bases;
+    const char **base_names= ((swig_lua_class*)(swig_type->clientdata))->base_names;
+    bases_count = 0;
+    for(;base_names[bases_count];
+      bases_count++);/* get length of bases */
+#endif
+
+    if(ret)
+      *ret = 0;
+    if(bases_count>0)
+    {
+      int to_remove;
+      size_t i;
+      int j;
+      int subcall_last_arg;
+      int subcall_first_arg = lua_gettop(L) + 1;/* Here a copy of first_arg and arguments begin */
+      int valid = 1;
+      swig_type_info *base_swig_type = 0;
+      for(j=first_arg;j<=last_arg;j++)
+        lua_pushvalue(L,j);
+      subcall_last_arg = lua_gettop(L);
+
+      /* Trick: temporarily replacing original metatable with metatable for base class and call getter */
+      for(i=0;i<bases_count;i++) {
+        /* Iteration through class bases */
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
+        lua_rawgeti(L,bases_table,i+1);
+        base_swig_type = 0;
+        if(lua_isnil(L,-1)) {
+          valid = 0;
+          lua_pop(L,1);
+        } else {
+          valid = 1;
+        }
+#else /* In elua .bases table doesn't exist. Use table from swig_lua_class */
+        swig_lua_class *base_class = bases[i];
+        if(!base_class) {
+          valid = 0;
+        } else {
+          valid = 1;
+          SWIG_Lua_get_class_metatable(L,base_class->fqname);
+          base_swig_type = SWIG_TypeQueryModule(module,module,base_names[i]);
+          assert(base_swig_type != 0);
+        }
+#endif
+
+        if(!valid)
+          continue;
+        assert(lua_isuserdata(L, subcall_first_arg));
+        assert(lua_istable(L,-1));
+        lua_setmetatable(L,subcall_first_arg); /* Set new metatable */
+        assert(lua_gettop(L) == subcall_last_arg);
+        result = func(L, base_swig_type,subcall_first_arg, ret); /* Forward call */
+        if(result != SWIG_ERROR) {
+          break;
+        }
+      }
+      /* Restore original metatable */
+      lua_pushvalue(L,original_metatable);
+      lua_setmetatable(L,first_arg);
+      /* Clear - remove everything between last_arg and subcall_last_arg including */
+      to_remove = subcall_last_arg - last_arg;
+      for(j=0;j<to_remove;j++)
+        lua_remove(L,last_arg+1);
+    } else {
+      /* Remove everything after last_arg */
+      lua_pop(L, lua_gettop(L) - last_arg);
+    }
+    if(ret) assert(lua_gettop(L) == last_arg + *ret);
+    return result;
+}
+
+/* The class.get method helper, performs the lookup of class attributes.
+ * It returns an error code. Number of function return values is passed inside 'ret'.
+ * first_arg is not used in this function because function always has 2 arguments.
+ */
+SWIGINTERN int  SWIG_Lua_class_do_get(lua_State *L, swig_type_info *type, int SWIGUNUSED first_arg, int *ret)
+{
+/*  there should be 2 params passed in
+  (1) userdata (not the meta table)
+  (2) string name of the attribute
+*/
+  int bases_search_result;
+  int substack_start = lua_gettop(L)-2;
+  assert(first_arg == substack_start+1);
+  lua_checkstack(L,5);
+  assert(lua_isuserdata(L,-2));  /* just in case */
+  lua_getmetatable(L,-2);    /* get the meta table */
+  assert(lua_istable(L,-1));  /* just in case */
+  SWIG_Lua_get_table(L,".get"); /* find the .get table */
+  assert(lua_istable(L,-1));  /* just in case */
+  /* look for the key in the .get table */
+  lua_pushvalue(L,substack_start+2);  /* key */
+  lua_rawget(L,-2);
+  lua_remove(L,-2); /* stack tidy, remove .get table */
+  if (lua_iscfunction(L,-1))
+  {  /* found it so call the fn & return its value */
+    lua_pushvalue(L,substack_start+1);  /* the userdata */
+    lua_call(L,1,1);  /* 1 value in (userdata),1 out (result) */
+    lua_remove(L,-2); /* stack tidy, remove metatable */
+    if(ret)
+      *ret = 1;
+    return SWIG_OK;
+  }
+  lua_pop(L,1);  /* remove whatever was there */
+  /* ok, so try the .fn table */
+  SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
+  assert(lua_istable(L,-1));  /* just in case */
+  lua_pushvalue(L,substack_start+2);  /* key */
+  lua_rawget(L,-2);  /* look for the fn */
+  lua_remove(L,-2); /* stack tidy, remove .fn table */
+  if (lua_isfunction(L,-1)) /* note: if its a C function or lua function */
+  {  /* found it so return the fn & let lua call it */
+    lua_remove(L,-2); /* stack tidy, remove metatable */
+    if(ret)
+      *ret = 1;
+    return SWIG_OK;
+  }
+  lua_pop(L,1);  /* remove whatever was there */
+  /* NEW: looks for the __getitem() fn
+  this is a user provided get fn */
+  SWIG_Lua_get_table(L,"__getitem"); /* find the __getitem fn */
+  if (lua_iscfunction(L,-1))  /* if its there */
+  {  /* found it so call the fn & return its value */
+    lua_pushvalue(L,substack_start+1);  /* the userdata */
+    lua_pushvalue(L,substack_start+2);  /* the parameter */
+    lua_call(L,2,1);  /* 2 value in (userdata),1 out (result) */
+    lua_remove(L,-2); /* stack tidy, remove metatable */
+    if(ret) *ret = 1;
+    return SWIG_OK;
+  }
+  lua_pop(L,1);
+  /* Remove the metatable */
+  lua_pop(L,1);
+  /* Search in base classes */
+  bases_search_result = SWIG_Lua_iterate_bases(L,type,substack_start+1,SWIG_Lua_class_do_get,ret);
+  return bases_search_result;  /* sorry not known */
+}
+
+/* the class.get method, performs the lookup of class attributes
+ */
+SWIGINTERN int  SWIG_Lua_class_get(lua_State *L)
+{
+/*  there should be 2 params passed in
+  (1) userdata (not the meta table)
+  (2) string name of the attribute
+*/
+  int result;
+  swig_lua_userdata *usr;
+  swig_type_info *type;
+  int ret = 0;
+  assert(lua_isuserdata(L,1));
+  usr=(swig_lua_userdata*)lua_touserdata(L,1);  /* get data */
+  type = usr->type;
+  result = SWIG_Lua_class_do_get(L,type,1,&ret);
+  if(result == SWIG_OK)
+    return ret;
+
+  return 0;
+}
+
+/* helper for the class.set method, performs the lookup of class attributes
+ * It returns error code. Number of function return values is passed inside 'ret'
+ */
+SWIGINTERN int  SWIG_Lua_class_do_set(lua_State *L, swig_type_info *type, int first_arg, int *ret)
+{
+/*  there should be 3 params passed in
+  (1) table (not the meta table)
+  (2) string name of the attribute
+  (3) any for the new value
+  */
+
+  int bases_search_result;
+  int substack_start = lua_gettop(L) - 3;
+  lua_checkstack(L,5);
+  assert(lua_isuserdata(L,substack_start+1));  /* just in case */
+  lua_getmetatable(L,substack_start+1);    /* get the meta table */
+  assert(lua_istable(L,-1));  /* just in case */
+  if(ret)
+    *ret = 0; /* it is setter - number of return values is always 0 */
+
+  SWIG_Lua_get_table(L,".set"); /* find the .set table */
+  if (lua_istable(L,-1))
+  {
+    /* look for the key in the .set table */
+    lua_pushvalue(L,substack_start+2);  /* key */
+    lua_rawget(L,-2);
+    lua_remove(L,-2); /* tidy stack, remove .set table */
+    if (lua_iscfunction(L,-1))
+    {  /* found it so call the fn & return its value */
+      lua_pushvalue(L,substack_start+1);  /* userdata */
+      lua_pushvalue(L,substack_start+3);  /* value */
+      lua_call(L,2,0);
+      lua_remove(L,substack_start+4); /*remove metatable*/
+      return SWIG_OK;
+    }
+    lua_pop(L,1);  /* remove the value */
+  } else {
+    lua_pop(L,1);  /* remove the answer for .set table request*/
+  }
+  /* NEW: looks for the __setitem() fn
+  this is a user provided set fn */
+  SWIG_Lua_get_table(L,"__setitem"); /* find the fn */
+  if (lua_iscfunction(L,-1))  /* if its there */
+  {  /* found it so call the fn & return its value */
+    lua_pushvalue(L,substack_start+1);  /* the userdata */
+    lua_pushvalue(L,substack_start+2);  /* the parameter */
+    lua_pushvalue(L,substack_start+3);  /* the value */
+    lua_call(L,3,0);  /* 3 values in ,0 out */
+    lua_remove(L,-2); /* stack tidy, remove metatable */
+    return SWIG_OK;
+  }
+  lua_pop(L,1); /* remove value */
+
+  lua_pop(L,1); /* remove metatable */
+  /* Search among bases */
+  bases_search_result = SWIG_Lua_iterate_bases(L,type,first_arg,SWIG_Lua_class_do_set,ret);
+  if(ret)
+    assert(*ret == 0);
+  assert(lua_gettop(L) == substack_start + 3);
+  return bases_search_result;
+}
+
+/* This is the actual method exported to Lua. It calls SWIG_Lua_class_do_set and correctly
+ * handles return values.
+ */
+SWIGINTERN int  SWIG_Lua_class_set(lua_State *L)
+{
+/*  There should be 3 params passed in
+  (1) table (not the meta table)
+  (2) string name of the attribute
+  (3) any for the new value
+  */
+  int ret = 0;
+  int result;
+  swig_lua_userdata *usr;
+  swig_type_info *type;
+  assert(lua_isuserdata(L,1));
+  usr=(swig_lua_userdata*)lua_touserdata(L,1);  /* get data */
+  type = usr->type;
+  result = SWIG_Lua_class_do_set(L,type,1,&ret);
+  if(result != SWIG_OK) {
+   SWIG_Lua_pushferrstring(L,"Assignment not possible. No setter/member with this name. For custom assignments implement __setitem method.");
+   lua_error(L);
+  } else {
+    assert(ret==0);
+  }
+  return 0;
+}
+
+/* the class.destruct method called by the interpreter */
+SWIGINTERN int  SWIG_Lua_class_destruct(lua_State *L)
+{
+/*  there should be 1 params passed in
+  (1) userdata (not the meta table) */
+  swig_lua_userdata *usr;
+  swig_lua_class *clss;
+  assert(lua_isuserdata(L,-1));  /* just in case */
+  usr=(swig_lua_userdata*)lua_touserdata(L,-1);  /* get it */
+  /* if must be destroyed & has a destructor */
+  if (usr->own) /* if must be destroyed */
+  {
+    clss=(swig_lua_class*)usr->type->clientdata;  /* get the class */
+    if (clss && clss->destructor)  /* there is a destroy fn */
+    {
+      clss->destructor(usr->ptr);  /* bye bye */
+    }
+  }
+  return 0;
+}
+
+/* the class.__tostring method called by the interpreter and print */
+SWIGINTERN int  SWIG_Lua_class_tostring(lua_State *L)
+{
+/*  there should be 1 param passed in
+  (1) userdata (not the metatable) */
+  const char *className;
+  void* userData;
+  assert(lua_isuserdata(L,1));  /* just in case */
+  userData = lua_touserdata(L,1); /* get the userdata address for later */
+  lua_getmetatable(L,1);    /* get the meta table */
+  assert(lua_istable(L,-1));  /* just in case */
+
+  lua_getfield(L, -1, ".type");
+  className = lua_tostring(L, -1);
+
+  lua_pushfstring(L, "<%s userdata: %p>", className, userData);
+  return 1;
+}
+
+/* to manually disown some userdata */
+SWIGINTERN int  SWIG_Lua_class_disown(lua_State *L)
+{
+/*  there should be 1 params passed in
+  (1) userdata (not the meta table) */
+  swig_lua_userdata *usr;
+  assert(lua_isuserdata(L,-1));  /* just in case */
+  usr=(swig_lua_userdata*)lua_touserdata(L,-1);  /* get it */
+  
+  usr->own = 0; /* clear our ownership */
+  return 0;
+}
+
+/* lua callable function to compare userdata's value
+the issue is that two userdata may point to the same thing
+but to lua, they are different objects */
+SWIGRUNTIME int SWIG_Lua_class_equal(lua_State *L)
+{
+  int result;
+  swig_lua_userdata *usr1,*usr2;
+  if (!lua_isuserdata(L,1) || !lua_isuserdata(L,2))  /* just in case */
+    return 0;  /* nil reply */
+  usr1=(swig_lua_userdata*)lua_touserdata(L,1);  /* get data */
+  usr2=(swig_lua_userdata*)lua_touserdata(L,2);  /* get data */
+  /*result=(usr1->ptr==usr2->ptr && usr1->type==usr2->type); only works if type is the same*/
+  result=(usr1->ptr==usr2->ptr);
+   lua_pushboolean(L,result);
+  return 1;
+}
+
+/* populate table at the top of the stack with metamethods that ought to be inherited */
+SWIGINTERN void SWIG_Lua_populate_inheritable_metamethods(lua_State *L)
+{
+  SWIG_Lua_add_boolean(L, "__add", 1);
+  SWIG_Lua_add_boolean(L, "__sub", 1);
+  SWIG_Lua_add_boolean(L, "__mul", 1);
+  SWIG_Lua_add_boolean(L, "__div", 1);
+  SWIG_Lua_add_boolean(L, "__mod", 1);
+  SWIG_Lua_add_boolean(L, "__pow", 1);
+  SWIG_Lua_add_boolean(L, "__unm", 1);
+  SWIG_Lua_add_boolean(L, "__len", 1 );
+  SWIG_Lua_add_boolean(L, "__concat", 1 );
+  SWIG_Lua_add_boolean(L, "__eq", 1);
+  SWIG_Lua_add_boolean(L, "__lt", 1);
+  SWIG_Lua_add_boolean(L, "__le", 1);
+  SWIG_Lua_add_boolean(L, "__call", 1);
+  SWIG_Lua_add_boolean(L, "__tostring", 1);
+  SWIG_Lua_add_boolean(L, "__gc", 0);
+}
+
+/* creates the swig registry */
+SWIGINTERN void SWIG_Lua_create_class_registry(lua_State *L)
+{
+  /* create main SWIG registry table */
+  lua_pushstring(L,"SWIG");
+  lua_newtable(L);
+  /* populate it with some predefined data */
+
+  /* .library table. Placeholder */
+  lua_pushstring(L,".library");
+  lua_newtable(L);
+  {
+    /* list of metamethods that class inherits from its bases */
+    lua_pushstring(L,"inheritable_metamethods");
+    lua_newtable(L);
+    /* populate with list of metamethods */
+    SWIG_Lua_populate_inheritable_metamethods(L);
+    lua_rawset(L,-3);
+  }
+  lua_rawset(L,-3);
+
+  lua_rawset(L,LUA_REGISTRYINDEX);
+}
+
+/* gets the swig registry (or creates it) */
+SWIGINTERN void  SWIG_Lua_get_class_registry(lua_State *L)
+{
+  /* add this all into the swig registry: */
+  lua_pushstring(L,"SWIG");
+  lua_rawget(L,LUA_REGISTRYINDEX);  /* get the registry */
+  if (!lua_istable(L,-1))  /* not there */
+  {  /* must be first time, so add it */
+    lua_pop(L,1);  /* remove the result */
+    SWIG_Lua_create_class_registry(L);
+    /* then get it */
+    lua_pushstring(L,"SWIG");
+    lua_rawget(L,LUA_REGISTRYINDEX);
+  }
+}
+
+SWIGINTERN void SWIG_Lua_get_inheritable_metamethods(lua_State *L)
+{
+  SWIG_Lua_get_class_registry(L);
+  lua_pushstring(L, ".library");
+  lua_rawget(L,-2);
+  assert( !lua_isnil(L,-1) );
+  lua_pushstring(L, "inheritable_metamethods");
+  lua_rawget(L,-2);
+
+  /* Remove class registry and library table */
+  lua_remove(L,-2);
+  lua_remove(L,-2);
+}
+
+/* Helper function to get the classes metatable from the register */
+SWIGINTERN void  SWIG_Lua_get_class_metatable(lua_State *L,const char *cname)
+{
+  SWIG_Lua_get_class_registry(L);  /* get the registry */
+  lua_pushstring(L,cname);  /* get the name */
+  lua_rawget(L,-2);    /* get it */
+  lua_remove(L,-2);    /* tidy up (remove registry) */
+}
+
+/* Set up the base classes pointers.
+Each class structure has a list of pointers to the base class structures.
+This function fills them.
+It cannot be done at compile time, as this will not work with hireachies
+spread over more than one swig file. 
+Therefore it must be done at runtime, querying the SWIG type system.
+*/
+SWIGINTERN void SWIG_Lua_init_base_class(lua_State *L,swig_lua_class *clss)
+{
+  int i=0;
+  swig_module_info *module=SWIG_GetModule(L);
+  for(i=0;clss->base_names[i];i++)
+  {
+    if (clss->bases[i]==0) /* not found yet */
+    {
+      /* lookup and cache the base class */
+      swig_type_info *info = SWIG_TypeQueryModule(module,module,clss->base_names[i]);
+      if (info) clss->bases[i] = (swig_lua_class *) info->clientdata;
+    }
+  }
+}
+
+#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
+/* Merges two tables  */
+SWIGINTERN void SWIG_Lua_merge_tables_by_index(lua_State *L, int target, int source)
+{
+  /* iterating */
+  lua_pushnil(L);
+  while (lua_next(L,source) != 0) {
+    /* -1 - value, -2 - index */
+    /* have to copy to assign */
+    lua_pushvalue(L,-2); /* copy of index */
+    lua_pushvalue(L,-2); /* copy of value */
+    lua_rawset(L, target);
+    lua_pop(L,1);
+    /* only key is left */
+  }
+}
+
+/* Merges two tables with given name. original - index of target metatable, base - index of source metatable */
+SWIGINTERN void SWIG_Lua_merge_tables(lua_State *L, const char* name, int original, int base)
+{
+  /* push original[name], then base[name] */
+  lua_pushstring(L,name);
+  lua_rawget(L,original);
+  int original_table = lua_gettop(L);
+  lua_pushstring(L,name);
+  lua_rawget(L,base);
+  int base_table = lua_gettop(L);
+  SWIG_Lua_merge_tables_by_index(L, original_table, base_table);
+  /* clearing stack */
+  lua_pop(L,2);
+}
+
+/* Function takes all symbols from base and adds it to derived class. It's just a helper. */
+SWIGINTERN void SWIG_Lua_class_squash_base(lua_State *L, swig_lua_class *base_cls)
+{
+  /* There is one parameter - original, i.e. 'derived' class metatable */
+  assert(lua_istable(L,-1));
+  int original = lua_gettop(L);
+  SWIG_Lua_get_class_metatable(L,base_cls->fqname);
+  int base = lua_gettop(L);
+  SWIG_Lua_merge_tables(L, ".fn", original, base );
+  SWIG_Lua_merge_tables(L, ".set", original, base );
+  SWIG_Lua_merge_tables(L, ".get", original, base );
+  lua_pop(L,1);
+}
+
+/* Function squashes all symbols from 'clss' bases into itself */
+SWIGINTERN void  SWIG_Lua_class_squash_bases(lua_State *L, swig_lua_class *clss)
+{
+  int i;
+  SWIG_Lua_get_class_metatable(L,clss->fqname);
+  for(i=0;clss->base_names[i];i++)
+  {
+    if (clss->bases[i]==0) /* Somehow it's not found. Skip it */
+      continue;
+    /* Thing is: all bases are already registered. Thus they have already executed
+     * this function. So we just need to squash them into us, because their bases
+     * are already squashed into them. No need for recursion here!
+     */
+    SWIG_Lua_class_squash_base(L, clss->bases[i]);
+  }
+  lua_pop(L,1); /*tidy stack*/
+}
+#endif
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */
+/* helper add a variable to a registered class */
+SWIGINTERN void  SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn)
+{
+  assert(lua_istable(L,-1));  /* just in case */
+  SWIG_Lua_get_table(L,".get"); /* find the .get table */
+  assert(lua_istable(L,-1));  /* just in case */
+  SWIG_Lua_add_function(L,name,getFn);
+  lua_pop(L,1);       /* tidy stack (remove table) */
+  if (setFn)
+  {
+    SWIG_Lua_get_table(L,".set"); /* find the .set table */
+    assert(lua_istable(L,-1));  /* just in case */
+    SWIG_Lua_add_function(L,name,setFn);
+    lua_pop(L,1);       /* tidy stack (remove table) */
+  }
+}
+
+/* helper to recursively add class static details (static attributes, operations and constants) */
+SWIGINTERN void SWIG_Lua_add_class_static_details(lua_State *L, swig_lua_class *clss)
+{
+  int i = 0;
+  /* The class namespace table must be on the top of the stack */
+  assert(lua_istable(L,-1));
+  /* call all the base classes first: we can then override these later: */
+  for(i=0;clss->bases[i];i++)
+  {
+    SWIG_Lua_add_class_static_details(L,clss->bases[i]);
+  }
+
+  SWIG_Lua_add_namespace_details(L, clss->cls_static);
+}
+
+SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss); /* forward declaration */
+
+/* helper to recursively add class details (attributes & operations) */
+SWIGINTERN void  SWIG_Lua_add_class_instance_details(lua_State *L, swig_lua_class *clss)
+{
+  int i;
+  size_t bases_count = 0;
+  /* Add bases to .bases table */
+  SWIG_Lua_get_table(L,".bases");
+  assert(lua_istable(L,-1));  /* just in case */
+  for(i=0;clss->bases[i];i++)
+  {
+    SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname);
+    /* Base class must be already registered */
+    assert(lua_istable(L,-1));
+    lua_rawseti(L,-2,i+1); /* In lua indexing starts from 1 */
+    bases_count++;
+  }
+  assert(lua_rawlen(L,-1) == bases_count);
+  lua_pop(L,1); /* remove .bases table */
+  /* add attributes */
+  for(i=0;clss->attributes[i].name;i++){
+    SWIG_Lua_add_variable(L,clss->attributes[i].name,clss->attributes[i].getmethod,clss->attributes[i].setmethod);
+  }
+  /* add methods to the metatable */
+  SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
+  assert(lua_istable(L,-1));  /* just in case */
+  for(i=0;clss->methods[i].name;i++){
+    SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].func);
+  }
+  lua_pop(L,1);       /* tidy stack (remove table) */
+  /* add operator overloads
+    This adds methods from metatable array to metatable. Can mess up garbage
+    collectind if someone defines __gc method
+    */
+  if(clss->metatable) {
+    for(i=0;clss->metatable[i].name;i++) {
+      SWIG_Lua_add_function(L,clss->metatable[i].name,clss->metatable[i].func);
+    }
+  }
+
+#if !defined(SWIG_LUA_SQUASH_BASES)
+  /* Adding metamethods that are defined in base classes. If bases were squashed
+   * then it is obviously unnecessary
+   */
+  SWIG_Lua_add_class_user_metamethods(L, clss);
+#endif
+}
+
+/* Helpers to add user defined class metamedhods - __add, __sub etc. The helpers are needed
+   for the following issue: Lua runtime checks for metamethod existence with rawget function
+   ignoring our SWIG-provided __index and __newindex functions. Thus our inheritance-aware method
+   search algorithm doesn't work in such case. (Not to say that Lua runtime queries metamethod directly
+   in metatable and not in object).
+   Current solution is this: if somewhere in hierarchy metamethod __x is defined, then all descendants
+   are automatically given a special proxy __x that calls the real __x method.
+   Obvious idea - to copy __x instead of creating __x-proxy is wrong because if someone changes __x in runtime,
+   those changes must be reflected in all descendants.
+*/
+
+SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L); /*forward declaration*/
+
+/* The real function that resolves a metamethod.
+ * Function searches given class and all it's bases(recursively) for first instance of something that is
+ * not equal to SWIG_Lua_resolve_metatmethod. (Almost always this 'something' is actual metamethod implementation
+ * and it is a SWIG-generated C function.). It returns value on the top of the L and there is no garbage below the
+ * answer.
+ * Returns 1 if found, 0 otherwise.
+ * clss is class which metatable we will search for method
+ * metamethod_name_idx is index in L where metamethod name (as string) lies
+ * skip_check allows to skip searching metamethod in givel clss and immideatelly go to searching in bases. skip_check
+ * is not caried to subsequent recursive calls - false is always passed. It is set to true only at first call from
+ * SWIG_Lua_resolve_metamethod
+ * */
+SWIGINTERN int SWIG_Lua_do_resolve_metamethod(lua_State *L, const swig_lua_class *clss, int metamethod_name_idx,
+    int skip_check)
+{
+  /* This function is called recursively */
+  int result = 0;
+  int i = 0;
+
+  if (!skip_check) {
+    SWIG_Lua_get_class_metatable(L, clss->fqname);
+    lua_pushvalue(L, metamethod_name_idx);
+    lua_rawget(L,-2);
+    /* If this is cfunction and it is equal to SWIG_Lua_resolve_metamethod then
+     * this isn't the function we are looking for :)
+     * lua_tocfunction will return NULL if not cfunction
+     */
+    if (!lua_isnil(L,-1) && lua_tocfunction(L,-1) != SWIG_Lua_resolve_metamethod ) {
+      lua_remove(L,-2); /* removing class metatable */
+      return 1;
+    }
+    lua_pop(L,2); /* remove class metatable and query result */
+  }
+
+  /* Forwarding calls to bases */
+  for(i=0;clss->bases[i];i++)
+  {
+    result = SWIG_Lua_do_resolve_metamethod(L, clss->bases[i], metamethod_name_idx, 0);
+    if (result)
+      break;
+  }
+
+  return result;
+}
+
+/* The proxy function for metamethod. All parameters are passed as cclosure. Searches for actual method
+ * and calls it */
+SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L)
+{
+  int numargs;
+  int metamethod_name_idx;
+  const swig_lua_class* clss;
+  int result;
+
+  lua_checkstack(L,5);
+  numargs = lua_gettop(L); /* number of arguments to pass to actual metamethod */
+  
+  /* Get upvalues from closure */
+  lua_pushvalue(L, lua_upvalueindex(1)); /*Get function name*/
+  metamethod_name_idx = lua_gettop(L);
+  
+  lua_pushvalue(L, lua_upvalueindex(2));
+  clss = (const swig_lua_class*)(lua_touserdata(L,-1));
+  lua_pop(L,1); /* remove lightuserdata with clss from stack */
+
+  /* Actual work */
+  result = SWIG_Lua_do_resolve_metamethod(L, clss, metamethod_name_idx, 1);
+  if (!result) {
+   SWIG_Lua_pushferrstring(L,"The metamethod proxy is set, but it failed to find actual metamethod. Memory corruption is most likely explanation.");
+   lua_error(L);
+   return 0;
+  }
+
+  lua_remove(L,-2); /* remove metamethod key */
+  lua_insert(L,1); /* move function to correct position */
+  lua_call(L, numargs, LUA_MULTRET);
+  return lua_gettop(L); /* return all results */
+}
+
+
+/* If given metamethod must be present in given class, then creates appropriate proxy
+ * Returns 1 if successfully added, 0 if not added because no base class has it, -1
+ * if method is defined in the class metatable itself
+ */
+SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class *clss, const int metatable_index)
+{
+  int key_index;
+  int success = 0;
+  int i = 0;
+
+  /* metamethod name - on the top of the stack */
+  assert(lua_isstring(L,-1));
+  
+  key_index = lua_gettop(L);
+
+  /* Check whether method is already defined in metatable */
+  lua_pushvalue(L,key_index); /* copy of the key */
+  lua_gettable(L,metatable_index);
+  if( !lua_isnil(L,-1) ) {
+    lua_pop(L,1);
+    return -1;
+  }
+  lua_pop(L,1); 
+
+  /* Iterating over immediate bases */
+  for(i=0;clss->bases[i];i++)
+  {
+    const swig_lua_class *base = clss->bases[i];
+    SWIG_Lua_get_class_metatable(L, base->fqname);
+    lua_pushvalue(L, key_index);
+    lua_rawget(L, -2);
+    if( !lua_isnil(L,-1) ) {
+      lua_pushvalue(L, key_index); 
+
+      /* Add proxy function */
+      lua_pushvalue(L, key_index); /* first closure value is function name */
+      lua_pushlightuserdata(L, clss); /* second closure value is swig_lua_class structure */
+      lua_pushcclosure(L, SWIG_Lua_resolve_metamethod, 2);
+      
+      lua_rawset(L, metatable_index);
+      success = 1;
+    }
+    lua_pop(L,1); /* remove function or nil */
+    lua_pop(L,1); /* remove base class metatable */
+
+    if( success )
+      break;
+  }
+
+  return success; 
+}
+
+SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss)
+{
+  int metatable_index;
+  int metamethods_info_index;
+  int tostring_undefined;
+  int eq_undefined = 0;
+
+  SWIG_Lua_get_class_metatable(L, clss->fqname);
+  metatable_index = lua_gettop(L);
+  SWIG_Lua_get_inheritable_metamethods(L);
+  assert(lua_istable(L,-1));
+  metamethods_info_index = lua_gettop(L);
+  lua_pushnil(L); /* first key */
+  while(lua_next(L, metamethods_info_index) != 0 ) {
+    /* key at index -2, value at index -1 */
+    const int is_inheritable = lua_toboolean(L,-2);
+    lua_pop(L,1); /* remove value - we don't need it anymore */
+
+    if(is_inheritable) { /* if metamethod is inheritable */
+      SWIG_Lua_add_class_user_metamethod(L,clss,metatable_index);
+    }
+  }
+
+  lua_pop(L,1); /* remove inheritable metatmethods table */
+
+  /* Special handling for __tostring method */
+  lua_pushstring(L, "__tostring");
+  lua_pushvalue(L,-1);
+  lua_rawget(L,metatable_index);
+  tostring_undefined = lua_isnil(L,-1);
+  lua_pop(L,1);
+  if( tostring_undefined ) {
+    lua_pushcfunction(L, SWIG_Lua_class_tostring);
+    lua_rawset(L, metatable_index);
+  } else {
+    lua_pop(L,1); /* remove copy of the key */
+  }
+
+  /* Special handling for __eq method */
+  lua_pushstring(L, "__eq");
+  lua_pushvalue(L,-1);
+  lua_rawget(L,metatable_index);
+  eq_undefined = lua_isnil(L,-1);
+  lua_pop(L,1);
+  if( eq_undefined ) {
+    lua_pushcfunction(L, SWIG_Lua_class_equal);
+    lua_rawset(L, metatable_index);
+  } else {
+    lua_pop(L,1); /* remove copy of the key */
+  }
+  /* Warning: __index and __newindex are SWIG-defined. For user-defined operator[]
+   * a __getitem/__setitem method should be defined
+   */
+  lua_pop(L,1); /* pop class metatable */
+}
+
+/* Register class static methods,attributes etc as well as constructor proxy */
+SWIGINTERN void SWIG_Lua_class_register_static(lua_State *L, swig_lua_class *clss)
+{
+  const int SWIGUNUSED begin = lua_gettop(L);
+  lua_checkstack(L,5); /* just in case */
+  assert(lua_istable(L,-1));  /* just in case */
+  assert(strcmp(clss->name, clss->cls_static->name) == 0); /* in class those 2 must be equal */
+
+  SWIG_Lua_namespace_register(L,clss->cls_static, 1);
+
+  assert(lua_istable(L,-1)); /* just in case */
+
+  /*  add its constructor to module with the name of the class
+  so you can do MyClass(...) as well as new_MyClass(...)
+  BUT only if a constructor is defined
+  (this overcomes the problem of pure virtual classes without constructors)*/
+  if (clss->constructor)
+  {
+    lua_getmetatable(L,-1);
+    assert(lua_istable(L,-1)); /* just in case */
+    SWIG_Lua_add_function(L,"__call", clss->constructor);
+    lua_pop(L,1);
+  }
+
+  assert(lua_istable(L,-1)); /* just in case */
+  SWIG_Lua_add_class_static_details(L, clss);
+
+  /* clear stack */
+  lua_pop(L,1);
+  assert( lua_gettop(L) == begin );
+}
+
+/* Performs the instance (non-static) class registration process. Metatable for class is created
+ * and added to the class registry.
+ */
+SWIGINTERN void  SWIG_Lua_class_register_instance(lua_State *L,swig_lua_class *clss)
+{
+  const int SWIGUNUSED begin = lua_gettop(L);
+  int i;
+  /* if name already there (class is already registered) then do nothing */
+  SWIG_Lua_get_class_registry(L);  /* get the registry */
+  lua_pushstring(L,clss->fqname);  /* get the name */
+  lua_rawget(L,-2);
+  if(!lua_isnil(L,-1)) {
+    lua_pop(L,2);
+    assert(lua_gettop(L)==begin);
+    return;
+  }
+  lua_pop(L,2); /* tidy stack */
+  /* Recursively initialize all bases */
+  for(i=0;clss->bases[i];i++)
+  {
+    SWIG_Lua_class_register_instance(L,clss->bases[i]);
+  }
+  /* Again, get registry and push name */
+  SWIG_Lua_get_class_registry(L);  /* get the registry */
+  lua_pushstring(L,clss->fqname);  /* get the name */
+  lua_newtable(L);    /* create the metatable */
+#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
+  /* If squashing is requested, then merges all bases metatable into this one.
+   * It would get us all special methods: __getitem, __add etc.
+   * This would set .fn, .type, and other .xxx incorrectly, but we will overwrite it right away
+   */
+  {
+    int new_metatable_index = lua_absindex(L,-1);
+    for(i=0;clss->bases[i];i++)
+    {
+      int base_metatable;
+      SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname);
+      base_metatable = lua_absindex(L,-1);
+      SWIG_Lua_merge_tables_by_index(L,new_metatable_index, base_metatable);
+      lua_pop(L,1);
+    }
+  }
+  /* And now we will overwrite all incorrectly set data */
+#endif
+  /* add string of class name called ".type" */
+  lua_pushstring(L,".type");
+  lua_pushstring(L,clss->fqname);
+  lua_rawset(L,-3);
+  /* add a table called bases */
+  lua_pushstring(L,".bases");
+  lua_newtable(L);
+  lua_rawset(L,-3);
+  /* add a table called ".get" */
+  lua_pushstring(L,".get");
+  lua_newtable(L);
+  lua_rawset(L,-3);
+  /* add a table called ".set" */
+  lua_pushstring(L,".set");
+  lua_newtable(L);
+  lua_rawset(L,-3);
+  /* add a table called ".fn" */
+  lua_pushstring(L,".fn");
+  lua_newtable(L);
+  /* add manual disown method */
+  SWIG_Lua_add_function(L,"__disown",SWIG_Lua_class_disown);
+  lua_rawset(L,-3);
+  /* add accessor fns for using the .get,.set&.fn */
+  SWIG_Lua_add_function(L,"__index",SWIG_Lua_class_get);
+  SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_class_set);
+  SWIG_Lua_add_function(L,"__gc",SWIG_Lua_class_destruct);
+  /* add it */
+  lua_rawset(L,-3);  /* metatable into registry */
+  lua_pop(L,1);      /* tidy stack (remove registry) */
+  assert(lua_gettop(L) == begin);
+
+#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
+  /* Now merge all symbols from .fn, .set, .get etc from bases to our tables */
+  SWIG_Lua_class_squash_bases(L,clss);
+#endif
+  SWIG_Lua_get_class_metatable(L,clss->fqname);
+  SWIG_Lua_add_class_instance_details(L,clss);  /* recursive adding of details (atts & ops) */
+  lua_pop(L,1);      /* tidy stack (remove class metatable) */
+  assert( lua_gettop(L) == begin );
+}
+
+SWIGINTERN void  SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss)
+{
+  int SWIGUNUSED begin;
+  assert(lua_istable(L,-1)); /* This is a table (module or namespace) where classes will be added */
+  SWIG_Lua_class_register_instance(L,clss);
+  SWIG_Lua_class_register_static(L,clss);
+
+  /* Add links from static part to instance part and vice versa */
+  /* [SWIG registry]                                   [Module]
+   *    "MyClass" ----> [MyClass metatable] <=====     "MyClass" -+> [static part]
+   *                     ".get" ----> ...        |                |     getmetatable()----|
+   *                     ".set" ----> ...        |                |                       |
+   *                     ".static" --------------)----------------/           [static part metatable]
+   *                                             |                                ".get" --> ...
+   *                                             |                                ".set" --> ....
+   *                                             |=============================== ".instance"
+   */
+  begin = lua_gettop(L);
+  lua_pushstring(L,clss->cls_static->name);
+  lua_rawget(L,-2); /* get class static table */
+  assert(lua_istable(L,-1));
+  lua_getmetatable(L,-1);
+  assert(lua_istable(L,-1)); /* get class static metatable */
+  lua_pushstring(L,".instance"); /* prepare key */
+
+  SWIG_Lua_get_class_metatable(L,clss->fqname); /* get class metatable */
+  assert(lua_istable(L,-1));
+  lua_pushstring(L,".static"); /* prepare key */
+  lua_pushvalue(L, -4); /* push static class TABLE */
+  assert(lua_istable(L,-1));
+  lua_rawset(L,-3); /* assign static class table(!NOT metatable) as ".static" member of class metatable */
+  lua_rawset(L,-3); /* assign class metatable as ".instance" member of class static METATABLE */
+  lua_pop(L,2);
+  assert(lua_gettop(L) == begin);
+}
+#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
+SWIGINTERN void SWIG_Lua_elua_class_register_instance(lua_State *L, swig_lua_class *clss)
+{
+  const int SWIGUNUSED begin = lua_gettop(L);
+  int i;
+  /* if name already there (class is already registered) then do nothing */
+  SWIG_Lua_get_class_registry(L);  /* get the registry */
+  lua_pushstring(L,clss->fqname);  /* get the name */
+  lua_rawget(L,-2);
+  if(!lua_isnil(L,-1)) {
+    lua_pop(L,2);
+    assert(lua_gettop(L)==begin);
+    return;
+  }
+  lua_pop(L,2); /* tidy stack */
+  /* Recursively initialize all bases */
+  for(i=0;clss->bases[i];i++)
+  {
+    SWIG_Lua_elua_class_register_instance(L,clss->bases[i]);
+  }
+  /* Again, get registry and push name */
+  SWIG_Lua_get_class_registry(L);  /* get the registry */
+  lua_pushstring(L,clss->fqname);  /* get the name */
+  assert(clss->metatable);
+  lua_pushrotable(L, (void*)(clss->metatable));    /* create the metatable */
+  lua_rawset(L,-3);
+  lua_pop(L,1);
+  assert(lua_gettop(L) == begin);
+}
+#endif /* elua && eluac */
+
+/* -----------------------------------------------------------------------------
+ * Class/structure conversion fns
+ * ----------------------------------------------------------------------------- */
+
+/* helper to add metatable to new lua object */
+SWIGINTERN void SWIG_Lua_AddMetatable(lua_State *L,swig_type_info *type)
+{
+  if (type->clientdata)  /* there is clientdata: so add the metatable */
+  {
+    SWIG_Lua_get_class_metatable(L,((swig_lua_class*)(type->clientdata))->fqname);
+    if (lua_istable(L,-1))
+    {
+      lua_setmetatable(L,-2);
+    }
+    else
+    {
+      lua_pop(L,1);
+    }
+  }
+}
+
+/* pushes a new object into the lua stack */
+SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own)
+{
+  swig_lua_userdata *usr;
+  if (!ptr){
+    lua_pushnil(L);
+    return;
+  }
+  usr=(swig_lua_userdata*)lua_newuserdata(L,sizeof(swig_lua_userdata));  /* get data */
+  usr->ptr=ptr;  /* set the ptr */
+  usr->type=type;
+  usr->own=own;
+#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
+  SWIG_Lua_AddMetatable(L,type); /* add metatable */
+#endif
+}
+
+/* takes a object from the lua stack & converts it into an object of the correct type
+ (if possible) */
+SWIGRUNTIME int  SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type_info *type,int flags)
+{
+  swig_lua_userdata *usr;
+  swig_cast_info *cast;
+  if (lua_isnil(L,index)){*ptr=0; return SWIG_OK;}    /* special case: lua nil => NULL pointer */
+  usr=(swig_lua_userdata*)lua_touserdata(L,index);  /* get data */
+  if (usr)
+  {
+    if (flags & SWIG_POINTER_DISOWN) /* must disown the object */
+    {
+        usr->own=0;
+    }
+    if (!type)            /* special cast void*, no casting fn */
+    {
+      *ptr=usr->ptr;
+      return SWIG_OK; /* ok */
+    }
+    cast=SWIG_TypeCheckStruct(usr->type,type); /* performs normal type checking */
+    if (cast)
+    {
+      int newmemory = 0;
+      *ptr=SWIG_TypeCast(cast,usr->ptr,&newmemory);
+      assert(!newmemory); /* newmemory handling not yet implemented */
+      return SWIG_OK;  /* ok */
+    }
+  }
+  return SWIG_ERROR;  /* error */
+}
+
+SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State *L,int index,swig_type_info *type,int flags,
+       int argnum,const char *func_name){
+  void *result;
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,index,&result,type,flags))){
+    luaL_error (L,"Error in %s, expected a %s at argument number %d\n",
+		func_name,(type && type->str)?type->str:"void*",argnum);
+  }
+  return result;
+}
+
+/* pushes a packed userdata. user for member fn pointers only */
+SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type)
+{
+  swig_lua_rawdata *raw;
+  assert(ptr); /* not acceptable to pass in a NULL value */
+  raw=(swig_lua_rawdata*)lua_newuserdata(L,sizeof(swig_lua_rawdata)-1+size);  /* alloc data */
+  raw->type=type;
+  raw->own=0;
+  memcpy(raw->data,ptr,size); /* copy the data */
+  SWIG_Lua_AddMetatable(L,type); /* add metatable */
+}
+    
+/* converts a packed userdata. user for member fn pointers only */
+SWIGRUNTIME int  SWIG_Lua_ConvertPacked(lua_State *L,int index,void *ptr,size_t size,swig_type_info *type)
+{
+  swig_lua_rawdata *raw;
+  raw=(swig_lua_rawdata*)lua_touserdata(L,index);  /* get data */
+  if (!raw) return SWIG_ERROR;  /* error */
+  if (type==0 || type==raw->type) /* void* or identical type */
+  {
+    memcpy(ptr,raw->data,size); /* copy it */
+    return SWIG_OK; /* ok */
+  }
+  return SWIG_ERROR;  /* error */
+}
+
+/* a function to get the typestring of a piece of data */
+SWIGRUNTIME const char *SWIG_Lua_typename(lua_State *L, int tp)
+{
+  swig_lua_userdata *usr;
+  if (lua_isuserdata(L,tp))
+  {
+    usr=(swig_lua_userdata*)lua_touserdata(L,tp);  /* get data */
+    if (usr && usr->type && usr->type->str)
+      return usr->type->str;
+    return "userdata (unknown type)";
+  }
+  return lua_typename(L,lua_type(L,tp));
+}
+
+/* lua callable function to get the userdata's type */
+SWIGRUNTIME int SWIG_Lua_type(lua_State *L)
+{
+  lua_pushstring(L,SWIG_Lua_typename(L,1));
+  return 1;
+}
+
+/* -----------------------------------------------------------------------------
+ * global variable support code: class/struct typemap functions
+ * ----------------------------------------------------------------------------- */
+
+#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
+/* Install Constants */
+SWIGINTERN void
+SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]) {
+  int i;
+  for (i = 0; constants[i].type; i++) {
+    switch(constants[i].type) {
+    case SWIG_LUA_INT:
+      lua_pushstring(L,constants[i].name);
+      lua_pushinteger(L,(lua_Number)constants[i].lvalue);
+      lua_rawset(L,-3);
+      break;
+    case SWIG_LUA_FLOAT:
+      lua_pushstring(L,constants[i].name);
+      lua_pushnumber(L,(lua_Number)constants[i].dvalue);
+      lua_rawset(L,-3);
+      break;
+    case SWIG_LUA_CHAR:
+      lua_pushstring(L,constants[i].name);
+      {
+        char c = constants[i].lvalue;
+        lua_pushlstring(L,&c,1);
+      }
+      lua_rawset(L,-3);
+      break;
+    case SWIG_LUA_STRING:
+      lua_pushstring(L,constants[i].name);
+      lua_pushstring(L,(char *) constants[i].pvalue);
+      lua_rawset(L,-3);
+      break;
+    case SWIG_LUA_POINTER:
+      lua_pushstring(L,constants[i].name);
+      SWIG_NewPointerObj(L,constants[i].pvalue, *(constants[i]).ptype,0);
+      lua_rawset(L,-3);
+      break;
+    case SWIG_LUA_BINARY:
+      lua_pushstring(L,constants[i].name);
+      SWIG_NewMemberObj(L,constants[i].pvalue,constants[i].lvalue,*(constants[i]).ptype);
+      lua_rawset(L,-3);
+      break;
+    default:
+      break;
+    }
+  }
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * executing lua code from within the wrapper
+ * ----------------------------------------------------------------------------- */
+
+#ifndef SWIG_DOSTRING_FAIL /* Allows redefining of error function */
+#define SWIG_DOSTRING_FAIL(S) fprintf(stderr,"%s\n",S)
+#endif
+/* Executes a C string in Lua which is a really simple way of calling lua from C
+Unfortunately lua keeps changing its APIs, so we need a conditional compile
+In lua 5.0.X it's lua_dostring()
+In lua 5.1.X it's luaL_dostring()
+*/
+SWIGINTERN int 
+SWIG_Lua_dostring(lua_State *L, const char *str) {
+  int ok,top;
+  if (str==0 || str[0]==0) return 0; /* nothing to do */
+  top=lua_gettop(L); /* save stack */
+#if (defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM>=501))
+  ok=luaL_dostring(L,str);	/* looks like this is lua 5.1.X or later, good */
+#else
+  ok=lua_dostring(L,str);	/* might be lua 5.0.x, using lua_dostring */
+#endif
+  if (ok!=0) {
+    SWIG_DOSTRING_FAIL(lua_tostring(L,-1));
+  }
+  lua_settop(L,top); /* restore the stack */
+  return ok;
+}    
+
+#ifdef __cplusplus
+}
+#endif
+
+/* ------------------------------ end luarun.swg  ------------------------------ */
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_Data swig_types[0]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr swig_types[1]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCDATASection swig_types[2]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData swig_types[3]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMComment swig_types[4]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument swig_types[5]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentFragment swig_types[6]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType swig_types[7]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement swig_types[8]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity swig_types[9]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntityReference swig_types[10]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException swig_types[11]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap swig_types[12]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode swig_types[13]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList swig_types[14]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation swig_types[15]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction swig_types[16]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText swig_types[17]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo swig_types[18]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMUserDataHandler swig_types[19]
+#define SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager swig_types[20]
+#define SWIGTYPE_p_bool swig_types[21]
+#define SWIGTYPE_p_int16_t swig_types[22]
+#define SWIGTYPE_p_int32_t swig_types[23]
+#define SWIGTYPE_p_int64_t swig_types[24]
+#define SWIGTYPE_p_namelist_t swig_types[25]
+#define SWIGTYPE_p_params_t swig_types[26]
+#define SWIGTYPE_p_size_t swig_types[27]
+#define SWIGTYPE_p_ssize_t swig_types[28]
+#define SWIGTYPE_p_std__listT_Data_t swig_types[29]
+#define SWIGTYPE_p_std__multimapT_std__string_Data_t swig_types[30]
+#define SWIGTYPE_p_std__string swig_types[31]
+#define SWIGTYPE_p_uint16_t swig_types[32]
+#define SWIGTYPE_p_uint32_t swig_types[33]
+#define SWIGTYPE_p_uint64_t swig_types[34]
+#define SWIGTYPE_p_unsigned_char swig_types[35]
+#define SWIGTYPE_p_uscxml__ErrorEvent swig_types[36]
+#define SWIGTYPE_p_uscxml__Event swig_types[37]
+#define SWIGTYPE_p_void swig_types[38]
+static swig_type_info *swig_types[40];
+static swig_module_info swig_module = {swig_types, 39, 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) -------- */
+
+#define SWIG_name      "LuaDOM"
+#define SWIG_init      luaopen_LuaDOM
+#define SWIG_init_user luaopen_LuaDOM_user
+
+#define SWIG_LUACODE   luaopen_LuaDOM_luacode
+
+namespace swig {
+typedef struct{} LANGUAGE_OBJ;
+}
+
+
+#include <string>
+
+
+SWIGINTERN int SWIG_lua_isnilstring(lua_State *L, int idx) {
+  int ret = lua_isstring(L, idx);
+  if (!ret)
+   ret = lua_isnil(L, idx);
+  return ret;
+}
+
+
+#include "xercesc/sax/InputSource.hpp"
+#include "xercesc/sax/SAXException.hpp"
+#include "xercesc/sax/SAXParseException.hpp"
+#include "xercesc/sax/Locator.hpp"
+#include "xercesc/sax/HandlerBase.hpp"
+#include "xercesc/sax2/Attributes.hpp"
+#include "xercesc/sax2/ContentHandler.hpp"
+#include "xercesc/sax2/LexicalHandler.hpp"
+#include "xercesc/sax2/DefaultHandler.hpp"
+#include "xercesc/sax2/SAX2XMLReader.hpp"
+#include "xercesc/sax2/XMLReaderFactory.hpp"
+#include "xercesc/util/PlatformUtils.hpp"
+#include "xercesc/util/TransService.hpp"
+#include "xercesc/util/XMLString.hpp"
+#include "xercesc/util/XMLUri.hpp"
+#include "xercesc/util/QName.hpp"
+#include "xercesc/util/HexBin.hpp"
+#include "xercesc/util/Base64.hpp"
+#include "xercesc/parsers/AbstractDOMParser.hpp"
+#include "xercesc/parsers/XercesDOMParser.hpp"
+#include "xercesc/parsers/SAXParser.hpp"
+#include "xercesc/dom/DOM.hpp"
+#include "xercesc/framework/LocalFileInputSource.hpp"
+#include "xercesc/framework/MemBufInputSource.hpp"
+#include "xercesc/framework/StdInInputSource.hpp"
+#include "xercesc/framework/URLInputSource.hpp"
+#include "xercesc/framework/XMLGrammarDescription.hpp"
+#include "xercesc/framework/XMLDTDDescription.hpp"
+#include "xercesc/framework/XMLSchemaDescription.hpp"
+#include "xercesc/util/NameIdPool.hpp"
+#include "xercesc/util/XMLEnumerator.hpp"
+#include "xercesc/framework/XMLValidator.hpp"
+#include "xercesc/validators/common/Grammar.hpp"
+#include "xercesc/validators/DTD/DTDAttDef.hpp"
+#include "xercesc/validators/DTD/DTDAttDefList.hpp"
+#include "xercesc/validators/DTD/DTDGrammar.hpp"
+#include "xercesc/validators/DTD/DTDValidator.hpp"
+#include "xercesc/validators/schema/SchemaGrammar.hpp"
+#include "xercesc/validators/schema/SchemaValidator.hpp"
+#include "xercesc/validators/schema/SchemaAttDefList.hpp"
+#include "xercesc/validators/schema/SchemaAttDef.hpp"
+#include "xercesc/framework/XMLFormatter.hpp"
+#include "xercesc/framework/MemBufFormatTarget.hpp"
+#include "xercesc/framework/LocalFileFormatTarget.hpp"
+#include "xercesc/framework/StdOutFormatTarget.hpp"
+#include "xercesc/framework/Wrapper4InputSource.hpp"
+#include "xercesc/framework/psvi/PSVIHandler.hpp"
+
+// for resolving XMLExceptions
+#include "xercesc/util/ArrayIndexOutOfBoundsException.hpp"
+#include "xercesc/util/EmptyStackException.hpp"
+#include "xercesc/util/IllegalArgumentException.hpp"
+#include "xercesc/util/InvalidCastException.hpp"
+#include "xercesc/util/IOException.hpp"
+#include "xercesc/util/NoSuchElementException.hpp"
+#include "xercesc/util/NullPointerException.hpp"
+#include "xercesc/util/NumberFormatException.hpp"
+#include "xercesc/util/ParseException.hpp"
+#include "xercesc/util/RuntimeException.hpp"
+#include "xercesc/util/SchemaDateTimeException.hpp"
+#include "xercesc/util/TranscodingException.hpp"
+#include "xercesc/util/UnexpectedEOFException.hpp"
+#include "xercesc/util/UnsupportedEncodingException.hpp"
+#include "xercesc/util/UTFDataFormatException.hpp"
+#include "xercesc/util/XMLNetAccessor.hpp"
+#include "xercesc/internal/XSerializationException.hpp"
+#include "xercesc/validators/datatype/InvalidDatatypeFacetException.hpp"
+#include "xercesc/validators/datatype/InvalidDatatypeValueException.hpp"
+#include "xercesc/validators/schema/identity/XPathException.hpp"
+
+XERCES_CPP_NAMESPACE_USE
+
+// we initialize the static UTF-8 transcoding info
+// these are used by the typemaps to convert between
+// Xerces internal UTF-16 and Perl's internal UTF-8
+static XMLCh* UTF8_ENCODING = NULL; 
+static XMLTranscoder* UTF8_TRANSCODER  = NULL;
+
+static bool DEBUG_UTF8_OUT = 0;
+static bool DEBUG_UTF8_IN = 0;
+
+
+
+static swig_type_info *
+DOMNode_dynamic_cast(void **ptr) {
+   DOMNode **nptr = (DOMNode **) ptr;
+   if (*nptr == NULL) {
+       return NULL;
+   }
+   short int type = (*nptr)->getNodeType();
+   if (type == DOMNode::TEXT_NODE) {
+      return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText;
+   }
+   if (type == DOMNode::PROCESSING_INSTRUCTION_NODE) {
+      return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction;
+   }
+   if (type == DOMNode::DOCUMENT_NODE) {
+      return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument;
+   }
+   if (type == DOMNode::ELEMENT_NODE) {
+      return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement;
+   }
+   if (type == DOMNode::ENTITY_REFERENCE_NODE) {
+      return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntityReference;
+   }
+   if (type == DOMNode::CDATA_SECTION_NODE) {
+      return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCDATASection;
+   }
+   if (type == DOMNode::CDATA_SECTION_NODE) {
+      return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCDATASection;
+   }
+   if (type == DOMNode::COMMENT_NODE) {
+      return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMComment;
+   }
+   if (type == DOMNode::DOCUMENT_TYPE_NODE) {
+      return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType;
+   }
+   if (type == DOMNode::ENTITY_NODE) {
+      return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity;
+   }
+   if (type == DOMNode::ATTRIBUTE_NODE) {
+      return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr;
+   }
+   if (type == DOMNode::NOTATION_NODE) {
+      return SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation;
+   }
+   return NULL;
+}
+
+SWIGINTERN bool XERCES_CPP_NAMESPACE_DOMNode_operator_Se__Se_(XERCES_CPP_NAMESPACE::DOMNode *self,XERCES_CPP_NAMESPACE::DOMNode const *other){
+       return self->isSameNode(other);
+   }
+
+using uscxml::Data;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+static int _wrap_new_string__SWIG_0(lua_State* L) {
+  int SWIG_arg = 0;
+  std::string *result = 0 ;
+  
+  SWIG_check_num_args("std::string::string",0,0)
+  result = (std::string *)new std::string();
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_new_string__SWIG_1(lua_State* L) {
+  int SWIG_arg = 0;
+  char *arg1 = (char *) 0 ;
+  std::string *result = 0 ;
+  
+  SWIG_check_num_args("std::string::string",1,1)
+  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("std::string::string",1,"char const *");
+  arg1 = (char *)lua_tostring(L, 1);
+  result = (std::string *)new std::string((char const *)arg1);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_new_string(lua_State* L) {
+  int argc;
+  int argv[2]={
+    1,2
+  };
+  
+  argc = lua_gettop(L);
+  if (argc == 0) {
+    return _wrap_new_string__SWIG_0(L);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      _v = SWIG_lua_isnilstring(L,argv[0]);
+    }
+    if (_v) {
+      return _wrap_new_string__SWIG_1(L);
+    }
+  }
+  
+  SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_string'\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    std::string::string()\n"
+    "    std::string::string(char const *)\n");
+  lua_error(L);return 0;
+}
+
+
+static int _wrap_string_size(lua_State* L) {
+  int SWIG_arg = 0;
+  std::string *arg1 = (std::string *) 0 ;
+  unsigned int result;
+  
+  SWIG_check_num_args("std::string::size",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::size",1,"std::string const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
+    SWIG_fail_ptr("string_size",1,SWIGTYPE_p_std__string);
+  }
+  
+  result = (unsigned int)((std::string const *)arg1)->size();
+  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_string_length(lua_State* L) {
+  int SWIG_arg = 0;
+  std::string *arg1 = (std::string *) 0 ;
+  unsigned int result;
+  
+  SWIG_check_num_args("std::string::length",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::length",1,"std::string const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
+    SWIG_fail_ptr("string_length",1,SWIGTYPE_p_std__string);
+  }
+  
+  result = (unsigned int)((std::string const *)arg1)->length();
+  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_string_empty(lua_State* L) {
+  int SWIG_arg = 0;
+  std::string *arg1 = (std::string *) 0 ;
+  bool result;
+  
+  SWIG_check_num_args("std::string::empty",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::empty",1,"std::string const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
+    SWIG_fail_ptr("string_empty",1,SWIGTYPE_p_std__string);
+  }
+  
+  result = (bool)((std::string const *)arg1)->empty();
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_string_c_str(lua_State* L) {
+  int SWIG_arg = 0;
+  std::string *arg1 = (std::string *) 0 ;
+  char *result = 0 ;
+  
+  SWIG_check_num_args("std::string::c_str",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::c_str",1,"std::string const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
+    SWIG_fail_ptr("string_c_str",1,SWIGTYPE_p_std__string);
+  }
+  
+  result = (char *)((std::string const *)arg1)->c_str();
+  lua_pushstring(L,(const char *)result); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_string_data(lua_State* L) {
+  int SWIG_arg = 0;
+  std::string *arg1 = (std::string *) 0 ;
+  char *result = 0 ;
+  
+  SWIG_check_num_args("std::string::data",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::data",1,"std::string const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
+    SWIG_fail_ptr("string_data",1,SWIGTYPE_p_std__string);
+  }
+  
+  result = (char *)((std::string const *)arg1)->data();
+  lua_pushstring(L,(const char *)result); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_string_assign(lua_State* L) {
+  int SWIG_arg = 0;
+  std::string *arg1 = (std::string *) 0 ;
+  char *arg2 = (char *) 0 ;
+  
+  SWIG_check_num_args("std::string::assign",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::assign",1,"std::string *");
+  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("std::string::assign",2,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
+    SWIG_fail_ptr("string_assign",1,SWIGTYPE_p_std__string);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
+  (arg1)->assign((char const *)arg2);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static void swig_delete_string(void *obj) {
+std::string *arg1 = (std::string *) obj;
+delete arg1;
+}
+static int _proxy__wrap_new_string(lua_State *L) {
+    assert(lua_istable(L,1));
+    lua_pushcfunction(L,_wrap_new_string);
+    assert(!lua_isnil(L,-1));
+    lua_replace(L,1); /* replace our table with real constructor */
+    lua_call(L,lua_gettop(L)-1,1);
+    return 1;
+}
+static swig_lua_attribute swig_string_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_method swig_string_methods[]= {
+    { "size", _wrap_string_size},
+    { "length", _wrap_string_length},
+    { "empty", _wrap_string_empty},
+    { "c_str", _wrap_string_c_str},
+    { "data", _wrap_string_data},
+    { "assign", _wrap_string_assign},
+    {0,0}
+};
+static swig_lua_method swig_string_meta[] = {
+    {0,0}
+};
+
+static swig_lua_attribute swig_string_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_string_Sf_SwigStatic_constants[]= {
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_string_Sf_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_string_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_string_Sf_SwigStatic = {
+    "string",
+    swig_string_Sf_SwigStatic_methods,
+    swig_string_Sf_SwigStatic_attributes,
+    swig_string_Sf_SwigStatic_constants,
+    swig_string_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_string_bases[] = {0};
+static const char *swig_string_base_names[] = {0};
+static swig_lua_class _wrap_class_string = { "string", "string", &SWIGTYPE_p_std__string,_proxy__wrap_new_string, swig_delete_string, swig_string_methods, swig_string_attributes, &swig_string_Sf_SwigStatic, swig_string_meta, swig_string_bases, swig_string_base_names };
+
+static int _wrap_DEBUG_UTF8_OUT_set(lua_State* L) {
+  int SWIG_arg = 0;
+  bool arg1 ;
+  
+  SWIG_check_num_args("DEBUG_UTF8_OUT",1,1)
+  if(!lua_isboolean(L,1)) SWIG_fail_arg("DEBUG_UTF8_OUT",1,"bool");
+  arg1 = (lua_toboolean(L, 1)!=0);
+  DEBUG_UTF8_OUT = arg1;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DEBUG_UTF8_OUT_get(lua_State* L) {
+  int SWIG_arg = 0;
+  bool result;
+  
+  SWIG_check_num_args("DEBUG_UTF8_OUT",0,0)
+  result = (bool)DEBUG_UTF8_OUT;
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DEBUG_UTF8_IN_set(lua_State* L) {
+  int SWIG_arg = 0;
+  bool arg1 ;
+  
+  SWIG_check_num_args("DEBUG_UTF8_IN",1,1)
+  if(!lua_isboolean(L,1)) SWIG_fail_arg("DEBUG_UTF8_IN",1,"bool");
+  arg1 = (lua_toboolean(L, 1)!=0);
+  DEBUG_UTF8_IN = arg1;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DEBUG_UTF8_IN_get(lua_State* L) {
+  int SWIG_arg = 0;
+  bool result;
+  
+  SWIG_check_num_args("DEBUG_UTF8_IN",0,0)
+  result = (bool)DEBUG_UTF8_IN;
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_new_DOMException__SWIG_0(lua_State* L) {
+  int SWIG_arg = 0;
+  short arg1 ;
+  short arg2 ;
+  XERCES_CPP_NAMESPACE::MemoryManager *arg3 = (XERCES_CPP_NAMESPACE::MemoryManager *) (XERCES_CPP_NAMESPACE::MemoryManager *)0 ;
+  XERCES_CPP_NAMESPACE::DOMException *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMException::DOMException",3,3)
+  if(!lua_isnumber(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMException::DOMException",1,"short");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMException::DOMException",2,"short");
+  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMException::DOMException",3,"XERCES_CPP_NAMESPACE::MemoryManager *const");
+  arg1 = (short)lua_tonumber(L, 1);
+  arg2 = (short)lua_tonumber(L, 2);
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager,0))){
+    SWIG_fail_ptr("new_DOMException",3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMException *)new XERCES_CPP_NAMESPACE::DOMException(arg1,arg2,arg3);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException,1); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_new_DOMException__SWIG_1(lua_State* L) {
+  int SWIG_arg = 0;
+  short arg1 ;
+  short arg2 ;
+  XERCES_CPP_NAMESPACE::DOMException *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMException::DOMException",2,2)
+  if(!lua_isnumber(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMException::DOMException",1,"short");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMException::DOMException",2,"short");
+  arg1 = (short)lua_tonumber(L, 1);
+  arg2 = (short)lua_tonumber(L, 2);
+  result = (XERCES_CPP_NAMESPACE::DOMException *)new XERCES_CPP_NAMESPACE::DOMException(arg1,arg2);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException,1); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_new_DOMException__SWIG_2(lua_State* L) {
+  int SWIG_arg = 0;
+  short arg1 ;
+  XERCES_CPP_NAMESPACE::DOMException *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMException::DOMException",1,1)
+  if(!lua_isnumber(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMException::DOMException",1,"short");
+  arg1 = (short)lua_tonumber(L, 1);
+  result = (XERCES_CPP_NAMESPACE::DOMException *)new XERCES_CPP_NAMESPACE::DOMException(arg1);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException,1); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_new_DOMException(lua_State* L) {
+  int argc;
+  int argv[4]={
+    1,2,3,4
+  };
+  
+  argc = lua_gettop(L);
+  if (argc == 1) {
+    int _v;
+    {
+      _v = lua_isnumber(L,argv[0]);
+    }
+    if (_v) {
+      return _wrap_new_DOMException__SWIG_2(L);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      _v = lua_isnumber(L,argv[0]);
+    }
+    if (_v) {
+      {
+        _v = lua_isnumber(L,argv[1]);
+      }
+      if (_v) {
+        return _wrap_new_DOMException__SWIG_1(L);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      _v = lua_isnumber(L,argv[0]);
+    }
+    if (_v) {
+      {
+        _v = lua_isnumber(L,argv[1]);
+      }
+      if (_v) {
+        {
+          void *ptr;
+          if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_XERCES_CPP_NAMESPACE__MemoryManager, 0)) {
+            _v = 0;
+          } else {
+            _v = 1;
+          }
+        }
+        if (_v) {
+          return _wrap_new_DOMException__SWIG_0(L);
+        }
+      }
+    }
+  }
+  
+  SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_DOMException'\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    XERCES_CPP_NAMESPACE::DOMException::DOMException(short,short,XERCES_CPP_NAMESPACE::MemoryManager *const)\n"
+    "    XERCES_CPP_NAMESPACE::DOMException::DOMException(short,short)\n"
+    "    XERCES_CPP_NAMESPACE::DOMException::DOMException(short)\n");
+  lua_error(L);return 0;
+}
+
+
+static int _wrap_DOMException_getMessage(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMException::getMessage",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMException::getMessage",1,"XERCES_CPP_NAMESPACE::DOMException const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException,0))){
+    SWIG_fail_ptr("DOMException_getMessage",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMException const *)arg1)->getMessage();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMException_code_set(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) 0 ;
+  short arg2 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMException::code",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMException::code",1,"XERCES_CPP_NAMESPACE::DOMException *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMException::code",2,"short");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException,0))){
+    SWIG_fail_ptr("DOMException_code_set",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException);
+  }
+  
+  arg2 = (short)lua_tonumber(L, 2);
+  if (arg1) (arg1)->code = arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMException_code_get(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) 0 ;
+  short result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMException::code",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMException::code",1,"XERCES_CPP_NAMESPACE::DOMException *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException,0))){
+    SWIG_fail_ptr("DOMException_code_get",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException);
+  }
+  
+  result = (short) ((arg1)->code);
+  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMException_msg_set(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMException::msg",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMException::msg",1,"XERCES_CPP_NAMESPACE::DOMException *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException,0))){
+    SWIG_fail_ptr("DOMException_msg_set",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  if (arg1) (arg1)->msg = (XMLCh const *)arg2;
+  
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMException_msg_get(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMException::msg",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMException::msg",1,"XERCES_CPP_NAMESPACE::DOMException *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException,0))){
+    SWIG_fail_ptr("DOMException_msg_get",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException);
+  }
+  
+  result = (XMLCh *) ((arg1)->msg);
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static void swig_delete_DOMException(void *obj) {
+XERCES_CPP_NAMESPACE::DOMException *arg1 = (XERCES_CPP_NAMESPACE::DOMException *) obj;
+delete arg1;
+}
+static int _proxy__wrap_new_DOMException(lua_State *L) {
+    assert(lua_istable(L,1));
+    lua_pushcfunction(L,_wrap_new_DOMException);
+    assert(!lua_isnil(L,-1));
+    lua_replace(L,1); /* replace our table with real constructor */
+    lua_call(L,lua_gettop(L)-1,1);
+    return 1;
+}
+static swig_lua_attribute swig_DOMException_attributes[] = {
+    { "code", _wrap_DOMException_code_get, _wrap_DOMException_code_set },
+    { "msg", _wrap_DOMException_msg_get, _wrap_DOMException_msg_set },
+    {0,0,0}
+};
+static swig_lua_method swig_DOMException_methods[]= {
+    { "getMessage", _wrap_DOMException_getMessage},
+    {0,0}
+};
+static swig_lua_method swig_DOMException_meta[] = {
+    {0,0}
+};
+
+static swig_lua_attribute swig_DOMException_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_DOMException_Sf_SwigStatic_constants[]= {
+    {SWIG_LUA_CONSTTAB_INT("INDEX_SIZE_ERR", XERCES_CPP_NAMESPACE::DOMException::INDEX_SIZE_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMSTRING_SIZE_ERR", XERCES_CPP_NAMESPACE::DOMException::DOMSTRING_SIZE_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("HIERARCHY_REQUEST_ERR", XERCES_CPP_NAMESPACE::DOMException::HIERARCHY_REQUEST_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("WRONG_DOCUMENT_ERR", XERCES_CPP_NAMESPACE::DOMException::WRONG_DOCUMENT_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("INVALID_CHARACTER_ERR", XERCES_CPP_NAMESPACE::DOMException::INVALID_CHARACTER_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("NO_DATA_ALLOWED_ERR", XERCES_CPP_NAMESPACE::DOMException::NO_DATA_ALLOWED_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("NO_MODIFICATION_ALLOWED_ERR", XERCES_CPP_NAMESPACE::DOMException::NO_MODIFICATION_ALLOWED_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("NOT_FOUND_ERR", XERCES_CPP_NAMESPACE::DOMException::NOT_FOUND_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("NOT_SUPPORTED_ERR", XERCES_CPP_NAMESPACE::DOMException::NOT_SUPPORTED_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("INUSE_ATTRIBUTE_ERR", XERCES_CPP_NAMESPACE::DOMException::INUSE_ATTRIBUTE_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("INVALID_STATE_ERR", XERCES_CPP_NAMESPACE::DOMException::INVALID_STATE_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("SYNTAX_ERR", XERCES_CPP_NAMESPACE::DOMException::SYNTAX_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("INVALID_MODIFICATION_ERR", XERCES_CPP_NAMESPACE::DOMException::INVALID_MODIFICATION_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("NAMESPACE_ERR", XERCES_CPP_NAMESPACE::DOMException::NAMESPACE_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("INVALID_ACCESS_ERR", XERCES_CPP_NAMESPACE::DOMException::INVALID_ACCESS_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("VALIDATION_ERR", XERCES_CPP_NAMESPACE::DOMException::VALIDATION_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("TYPE_MISMATCH_ERR", XERCES_CPP_NAMESPACE::DOMException::TYPE_MISMATCH_ERR)},
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_DOMException_Sf_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_DOMException_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_DOMException_Sf_SwigStatic = {
+    "DOMException",
+    swig_DOMException_Sf_SwigStatic_methods,
+    swig_DOMException_Sf_SwigStatic_attributes,
+    swig_DOMException_Sf_SwigStatic_constants,
+    swig_DOMException_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_DOMException_bases[] = {0};
+static const char *swig_DOMException_base_names[] = {0};
+static swig_lua_class _wrap_class_DOMException = { "DOMException", "DOMException", &SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMException,_proxy__wrap_new_DOMException, swig_delete_DOMException, swig_DOMException_methods, swig_DOMException_attributes, &swig_DOMException_Sf_SwigStatic, swig_DOMException_meta, swig_DOMException_bases, swig_DOMException_base_names };
+
+static int _wrap_DOMNode_getNodeName(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::getNodeName",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::getNodeName",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_getNodeName",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getNodeName();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_getNodeValue(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::getNodeValue",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::getNodeValue",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_getNodeValue",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getNodeValue();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_getNodeType(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode::NodeType result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::getNodeType",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::getNodeType",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_getNodeType",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNode::NodeType)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getNodeType();
+  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_getParentNode(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::getParentNode",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::getParentNode",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_getParentNode",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getParentNode();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_getChildNodes(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNodeList *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::getChildNodes",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::getChildNodes",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_getChildNodes",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNodeList *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getChildNodes();
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList,0); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_getFirstChild(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::getFirstChild",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::getFirstChild",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_getFirstChild",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getFirstChild();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_getLastChild(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::getLastChild",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::getLastChild",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_getLastChild",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getLastChild();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_getPreviousSibling(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::getPreviousSibling",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::getPreviousSibling",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_getPreviousSibling",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getPreviousSibling();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_getNextSibling(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::getNextSibling",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::getNextSibling",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_getNextSibling",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getNextSibling();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_getAttributes(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNamedNodeMap *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::getAttributes",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::getAttributes",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_getAttributes",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getAttributes();
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,0); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_getOwnerDocument(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMDocument *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::getOwnerDocument",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::getOwnerDocument",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_getOwnerDocument",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMDocument *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getOwnerDocument();
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocument,0); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_cloneNode(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  bool arg2 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::cloneNode",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::cloneNode",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  if(!lua_isboolean(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::cloneNode",2,"bool");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_cloneNode",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  arg2 = (lua_toboolean(L, 2)!=0);
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->cloneNode(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_insertBefore(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *arg3 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::insertBefore",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::insertBefore",1,"XERCES_CPP_NAMESPACE::DOMNode *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::insertBefore",2,"XERCES_CPP_NAMESPACE::DOMNode *");
+  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::insertBefore",3,"XERCES_CPP_NAMESPACE::DOMNode *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_insertBefore",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_insertBefore",2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_insertBefore",3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->insertBefore(arg2,arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_replaceChild(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *arg3 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::replaceChild",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::replaceChild",1,"XERCES_CPP_NAMESPACE::DOMNode *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::replaceChild",2,"XERCES_CPP_NAMESPACE::DOMNode *");
+  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::replaceChild",3,"XERCES_CPP_NAMESPACE::DOMNode *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_replaceChild",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_replaceChild",2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_replaceChild",3,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->replaceChild(arg2,arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_removeChild(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::removeChild",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::removeChild",1,"XERCES_CPP_NAMESPACE::DOMNode *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::removeChild",2,"XERCES_CPP_NAMESPACE::DOMNode *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_removeChild",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_removeChild",2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->removeChild(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_appendChild(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::appendChild",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::appendChild",1,"XERCES_CPP_NAMESPACE::DOMNode *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::appendChild",2,"XERCES_CPP_NAMESPACE::DOMNode *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_appendChild",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_appendChild",2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->appendChild(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_hasChildNodes(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  bool result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::hasChildNodes",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::hasChildNodes",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_hasChildNodes",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->hasChildNodes();
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_setNodeValue(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::setNodeValue",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::setNodeValue",1,"XERCES_CPP_NAMESPACE::DOMNode *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_setNodeValue",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  (arg1)->setNodeValue((XMLCh const *)arg2);
+  
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_normalize(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::normalize",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::normalize",1,"XERCES_CPP_NAMESPACE::DOMNode *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_normalize",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  (arg1)->normalize();
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_isSupported(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XMLCh *arg3 = (XMLCh *) 0 ;
+  bool result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::isSupported",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::isSupported",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_isSupported",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  
+  arg3 = Lua2XMLString(3);
+  
+  result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->isSupported((XMLCh const *)arg2,(XMLCh const *)arg3);
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_getNamespaceURI(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::getNamespaceURI",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::getNamespaceURI",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_getNamespaceURI",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getNamespaceURI();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_getLocalName(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::getLocalName",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::getLocalName",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_getLocalName",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getLocalName();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_setPrefix(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::setPrefix",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::setPrefix",1,"XERCES_CPP_NAMESPACE::DOMNode *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_setPrefix",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  (arg1)->setPrefix((XMLCh const *)arg2);
+  
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_hasAttributes(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  bool result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::hasAttributes",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::hasAttributes",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_hasAttributes",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->hasAttributes();
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_isSameNode(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  bool result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::isSameNode",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::isSameNode",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::isSameNode",2,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_isSameNode",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_isSameNode",2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->isSameNode((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_isEqualNode(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  bool result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::isEqualNode",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::isEqualNode",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::isEqualNode",2,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_isEqualNode",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_isEqualNode",2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->isEqualNode((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_setUserData(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  void *arg3 = (void *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMUserDataHandler *arg4 = (XERCES_CPP_NAMESPACE::DOMUserDataHandler *) 0 ;
+  void *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::setUserData",4,4)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::setUserData",1,"XERCES_CPP_NAMESPACE::DOMNode *");
+  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::setUserData",3,"void *");
+  if(!SWIG_isptrtype(L,4)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::setUserData",4,"XERCES_CPP_NAMESPACE::DOMUserDataHandler *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_setUserData",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"DOMNode_setUserData");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMUserDataHandler,0))){
+    SWIG_fail_ptr("DOMNode_setUserData",4,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMUserDataHandler);
+  }
+  
+  result = (void *)(arg1)->setUserData((XMLCh const *)arg2,arg3,arg4);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_void,0); SWIG_arg++; 
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_getUserData(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  void *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::getUserData",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::getUserData",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_getUserData",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  result = (void *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getUserData((XMLCh const *)arg2);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_void,0); SWIG_arg++; 
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_getBaseURI(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::getBaseURI",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::getBaseURI",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_getBaseURI",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getBaseURI();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_compareDocumentPosition(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  short result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::compareDocumentPosition",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::compareDocumentPosition",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::compareDocumentPosition",2,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_compareDocumentPosition",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_compareDocumentPosition",2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (short)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->compareDocumentPosition((XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_getTextContent(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::getTextContent",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::getTextContent",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_getTextContent",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getTextContent();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_setTextContent(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::setTextContent",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::setTextContent",1,"XERCES_CPP_NAMESPACE::DOMNode *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_setTextContent",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  (arg1)->setTextContent((XMLCh const *)arg2);
+  
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_lookupPrefix(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::lookupPrefix",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::lookupPrefix",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_lookupPrefix",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->lookupPrefix((XMLCh const *)arg2);
+  
+  result = XMLString2Lua(result);
+  
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_isDefaultNamespace(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  bool result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::isDefaultNamespace",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::isDefaultNamespace",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_isDefaultNamespace",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  result = (bool)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->isDefaultNamespace((XMLCh const *)arg2);
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_lookupNamespaceURI(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::lookupNamespaceURI",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::lookupNamespaceURI",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_lookupNamespaceURI",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->lookupNamespaceURI((XMLCh const *)arg2);
+  
+  result = XMLString2Lua(result);
+  
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_getFeature(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XMLCh *arg3 = (XMLCh *) 0 ;
+  void *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::getFeature",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::getFeature",1,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_getFeature",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  
+  arg3 = Lua2XMLString(3);
+  
+  result = (void *)((XERCES_CPP_NAMESPACE::DOMNode const *)arg1)->getFeature((XMLCh const *)arg2,(XMLCh const *)arg3);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_void,0); SWIG_arg++; 
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode_release(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::release",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::release",1,"XERCES_CPP_NAMESPACE::DOMNode *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode_release",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  (arg1)->release();
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNode___eq(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  bool result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNode::operator ==",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::operator ==",1,"XERCES_CPP_NAMESPACE::DOMNode *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNode::operator ==",2,"XERCES_CPP_NAMESPACE::DOMNode const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode___eq",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNode___eq",2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (bool)XERCES_CPP_NAMESPACE_DOMNode_operator_Se__Se_(arg1,(XERCES_CPP_NAMESPACE::DOMNode const *)arg2);
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static void swig_delete_DOMNode(void *obj) {
+XERCES_CPP_NAMESPACE::DOMNode *arg1 = (XERCES_CPP_NAMESPACE::DOMNode *) obj;
+delete arg1;
+}
+static swig_lua_attribute swig_DOMNode_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_method swig_DOMNode_methods[]= {
+    { "getNodeName", _wrap_DOMNode_getNodeName},
+    { "getNodeValue", _wrap_DOMNode_getNodeValue},
+    { "getNodeType", _wrap_DOMNode_getNodeType},
+    { "getParentNode", _wrap_DOMNode_getParentNode},
+    { "getChildNodes", _wrap_DOMNode_getChildNodes},
+    { "getFirstChild", _wrap_DOMNode_getFirstChild},
+    { "getLastChild", _wrap_DOMNode_getLastChild},
+    { "getPreviousSibling", _wrap_DOMNode_getPreviousSibling},
+    { "getNextSibling", _wrap_DOMNode_getNextSibling},
+    { "getAttributes", _wrap_DOMNode_getAttributes},
+    { "getOwnerDocument", _wrap_DOMNode_getOwnerDocument},
+    { "cloneNode", _wrap_DOMNode_cloneNode},
+    { "insertBefore", _wrap_DOMNode_insertBefore},
+    { "replaceChild", _wrap_DOMNode_replaceChild},
+    { "removeChild", _wrap_DOMNode_removeChild},
+    { "appendChild", _wrap_DOMNode_appendChild},
+    { "hasChildNodes", _wrap_DOMNode_hasChildNodes},
+    { "setNodeValue", _wrap_DOMNode_setNodeValue},
+    { "normalize", _wrap_DOMNode_normalize},
+    { "isSupported", _wrap_DOMNode_isSupported},
+    { "getNamespaceURI", _wrap_DOMNode_getNamespaceURI},
+    { "getLocalName", _wrap_DOMNode_getLocalName},
+    { "setPrefix", _wrap_DOMNode_setPrefix},
+    { "hasAttributes", _wrap_DOMNode_hasAttributes},
+    { "isSameNode", _wrap_DOMNode_isSameNode},
+    { "isEqualNode", _wrap_DOMNode_isEqualNode},
+    { "setUserData", _wrap_DOMNode_setUserData},
+    { "getUserData", _wrap_DOMNode_getUserData},
+    { "getBaseURI", _wrap_DOMNode_getBaseURI},
+    { "compareDocumentPosition", _wrap_DOMNode_compareDocumentPosition},
+    { "getTextContent", _wrap_DOMNode_getTextContent},
+    { "setTextContent", _wrap_DOMNode_setTextContent},
+    { "lookupPrefix", _wrap_DOMNode_lookupPrefix},
+    { "isDefaultNamespace", _wrap_DOMNode_isDefaultNamespace},
+    { "lookupNamespaceURI", _wrap_DOMNode_lookupNamespaceURI},
+    { "getFeature", _wrap_DOMNode_getFeature},
+    { "release", _wrap_DOMNode_release},
+    { "__eq", _wrap_DOMNode___eq},
+    {0,0}
+};
+static swig_lua_method swig_DOMNode_meta[] = {
+    { "__eq", _wrap_DOMNode___eq},
+    {0,0}
+};
+
+static swig_lua_attribute swig_DOMNode_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_DOMNode_Sf_SwigStatic_constants[]= {
+    {SWIG_LUA_CONSTTAB_INT("ELEMENT_NODE", XERCES_CPP_NAMESPACE::DOMNode::ELEMENT_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("ATTRIBUTE_NODE", XERCES_CPP_NAMESPACE::DOMNode::ATTRIBUTE_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("TEXT_NODE", XERCES_CPP_NAMESPACE::DOMNode::TEXT_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("CDATA_SECTION_NODE", XERCES_CPP_NAMESPACE::DOMNode::CDATA_SECTION_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("ENTITY_REFERENCE_NODE", XERCES_CPP_NAMESPACE::DOMNode::ENTITY_REFERENCE_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("ENTITY_NODE", XERCES_CPP_NAMESPACE::DOMNode::ENTITY_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("PROCESSING_INSTRUCTION_NODE", XERCES_CPP_NAMESPACE::DOMNode::PROCESSING_INSTRUCTION_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("COMMENT_NODE", XERCES_CPP_NAMESPACE::DOMNode::COMMENT_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("DOCUMENT_NODE", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("DOCUMENT_TYPE_NODE", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_TYPE_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("DOCUMENT_FRAGMENT_NODE", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_FRAGMENT_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("NOTATION_NODE", XERCES_CPP_NAMESPACE::DOMNode::NOTATION_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("DOCUMENT_POSITION_DISCONNECTED", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_DISCONNECTED)},
+    {SWIG_LUA_CONSTTAB_INT("DOCUMENT_POSITION_PRECEDING", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_PRECEDING)},
+    {SWIG_LUA_CONSTTAB_INT("DOCUMENT_POSITION_FOLLOWING", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_FOLLOWING)},
+    {SWIG_LUA_CONSTTAB_INT("DOCUMENT_POSITION_CONTAINS", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_CONTAINS)},
+    {SWIG_LUA_CONSTTAB_INT("DOCUMENT_POSITION_CONTAINED_BY", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_CONTAINED_BY)},
+    {SWIG_LUA_CONSTTAB_INT("DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC)},
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_DOMNode_Sf_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_DOMNode_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_DOMNode_Sf_SwigStatic = {
+    "DOMNode",
+    swig_DOMNode_Sf_SwigStatic_methods,
+    swig_DOMNode_Sf_SwigStatic_attributes,
+    swig_DOMNode_Sf_SwigStatic_constants,
+    swig_DOMNode_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_DOMNode_bases[] = {0};
+static const char *swig_DOMNode_base_names[] = {0};
+static swig_lua_class _wrap_class_DOMNode = { "DOMNode", "DOMNode", &SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0, swig_delete_DOMNode, swig_DOMNode_methods, swig_DOMNode_attributes, &swig_DOMNode_Sf_SwigStatic, swig_DOMNode_meta, swig_DOMNode_bases, swig_DOMNode_base_names };
+
+static int _wrap_DOMAttr_getName(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMAttr::getName",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMAttr::getName",1,"XERCES_CPP_NAMESPACE::DOMAttr const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr,0))){
+    SWIG_fail_ptr("DOMAttr_getName",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->getName();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMAttr_getSpecified(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+  bool result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMAttr::getSpecified",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMAttr::getSpecified",1,"XERCES_CPP_NAMESPACE::DOMAttr const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr,0))){
+    SWIG_fail_ptr("DOMAttr_getSpecified",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr);
+  }
+  
+  result = (bool)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->getSpecified();
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMAttr_getValue(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMAttr::getValue",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMAttr::getValue",1,"XERCES_CPP_NAMESPACE::DOMAttr const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr,0))){
+    SWIG_fail_ptr("DOMAttr_getValue",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->getValue();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMAttr_setValue(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMAttr::setValue",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMAttr::setValue",1,"XERCES_CPP_NAMESPACE::DOMAttr *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr,0))){
+    SWIG_fail_ptr("DOMAttr_setValue",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  (arg1)->setValue((XMLCh const *)arg2);
+  
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMAttr_getOwnerElement(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMAttr::getOwnerElement",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMAttr::getOwnerElement",1,"XERCES_CPP_NAMESPACE::DOMAttr const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr,0))){
+    SWIG_fail_ptr("DOMAttr_getOwnerElement",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMElement *)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->getOwnerElement();
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMAttr_isId(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+  bool result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMAttr::isId",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMAttr::isId",1,"XERCES_CPP_NAMESPACE::DOMAttr const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr,0))){
+    SWIG_fail_ptr("DOMAttr_isId",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr);
+  }
+  
+  result = (bool)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->isId();
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMAttr_getSchemaTypeInfo(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMTypeInfo *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMAttr::getSchemaTypeInfo",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMAttr::getSchemaTypeInfo",1,"XERCES_CPP_NAMESPACE::DOMAttr const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr,0))){
+    SWIG_fail_ptr("DOMAttr_getSchemaTypeInfo",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMTypeInfo *)((XERCES_CPP_NAMESPACE::DOMAttr const *)arg1)->getSchemaTypeInfo();
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo,0); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static void swig_delete_DOMAttr(void *obj) {
+XERCES_CPP_NAMESPACE::DOMAttr *arg1 = (XERCES_CPP_NAMESPACE::DOMAttr *) obj;
+delete arg1;
+}
+static swig_lua_attribute swig_DOMAttr_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_method swig_DOMAttr_methods[]= {
+    { "getName", _wrap_DOMAttr_getName},
+    { "getSpecified", _wrap_DOMAttr_getSpecified},
+    { "getValue", _wrap_DOMAttr_getValue},
+    { "setValue", _wrap_DOMAttr_setValue},
+    { "getOwnerElement", _wrap_DOMAttr_getOwnerElement},
+    { "isId", _wrap_DOMAttr_isId},
+    { "getSchemaTypeInfo", _wrap_DOMAttr_getSchemaTypeInfo},
+    {0,0}
+};
+static swig_lua_method swig_DOMAttr_meta[] = {
+    {0,0}
+};
+
+static swig_lua_attribute swig_DOMAttr_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_DOMAttr_Sf_SwigStatic_constants[]= {
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_DOMAttr_Sf_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_DOMAttr_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_DOMAttr_Sf_SwigStatic = {
+    "DOMAttr",
+    swig_DOMAttr_Sf_SwigStatic_methods,
+    swig_DOMAttr_Sf_SwigStatic_attributes,
+    swig_DOMAttr_Sf_SwigStatic_constants,
+    swig_DOMAttr_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_DOMAttr_bases[] = {0,0};
+static const char *swig_DOMAttr_base_names[] = {"XERCES_CPP_NAMESPACE::DOMNode *",0};
+static swig_lua_class _wrap_class_DOMAttr = { "DOMAttr", "DOMAttr", &SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr,0, swig_delete_DOMAttr, swig_DOMAttr_methods, swig_DOMAttr_attributes, &swig_DOMAttr_Sf_SwigStatic, swig_DOMAttr_meta, swig_DOMAttr_bases, swig_DOMAttr_base_names };
+
+static int _wrap_DOMElement_getTagName(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::getTagName",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::getTagName",1,"XERCES_CPP_NAMESPACE::DOMElement const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_getTagName",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getTagName();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_getAttribute(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::getAttribute",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::getAttribute",1,"XERCES_CPP_NAMESPACE::DOMElement const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_getAttribute",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getAttribute((XMLCh const *)arg2);
+  
+  result = XMLString2Lua(result);
+  
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_getAttributeNode(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::getAttributeNode",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::getAttributeNode",1,"XERCES_CPP_NAMESPACE::DOMElement const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_getAttributeNode",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  result = (XERCES_CPP_NAMESPACE::DOMAttr *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getAttributeNode((XMLCh const *)arg2);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr,0); SWIG_arg++; 
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_getElementsByTagName(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNodeList *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::getElementsByTagName",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::getElementsByTagName",1,"XERCES_CPP_NAMESPACE::DOMElement const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_getElementsByTagName",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNodeList *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getElementsByTagName((XMLCh const *)arg2);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList,0); SWIG_arg++; 
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_setAttribute(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XMLCh *arg3 = (XMLCh *) 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::setAttribute",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::setAttribute",1,"XERCES_CPP_NAMESPACE::DOMElement *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_setAttribute",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  
+  arg3 = Lua2XMLString(3);
+  
+  (arg1)->setAttribute((XMLCh const *)arg2,(XMLCh const *)arg3);
+  
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_setAttributeNode(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMAttr *arg2 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::setAttributeNode",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::setAttributeNode",1,"XERCES_CPP_NAMESPACE::DOMElement *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::setAttributeNode",2,"XERCES_CPP_NAMESPACE::DOMAttr *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_setAttributeNode",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr,0))){
+    SWIG_fail_ptr("DOMElement_setAttributeNode",2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMAttr *)(arg1)->setAttributeNode(arg2);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr,0); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_removeAttributeNode(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMAttr *arg2 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::removeAttributeNode",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::removeAttributeNode",1,"XERCES_CPP_NAMESPACE::DOMElement *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::removeAttributeNode",2,"XERCES_CPP_NAMESPACE::DOMAttr *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_removeAttributeNode",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr,0))){
+    SWIG_fail_ptr("DOMElement_removeAttributeNode",2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMAttr *)(arg1)->removeAttributeNode(arg2);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr,0); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_removeAttribute(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::removeAttribute",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::removeAttribute",1,"XERCES_CPP_NAMESPACE::DOMElement *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_removeAttribute",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  (arg1)->removeAttribute((XMLCh const *)arg2);
+  
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_getAttributeNS(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XMLCh *arg3 = (XMLCh *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::getAttributeNS",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::getAttributeNS",1,"XERCES_CPP_NAMESPACE::DOMElement const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_getAttributeNS",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  
+  arg3 = Lua2XMLString(3);
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getAttributeNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+  
+  result = XMLString2Lua(result);
+  
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_setAttributeNS(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XMLCh *arg3 = (XMLCh *) 0 ;
+  XMLCh *arg4 = (XMLCh *) 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::setAttributeNS",4,4)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::setAttributeNS",1,"XERCES_CPP_NAMESPACE::DOMElement *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_setAttributeNS",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  
+  arg3 = Lua2XMLString(3);
+  
+  
+  arg4 = Lua2XMLString(4);
+  
+  (arg1)->setAttributeNS((XMLCh const *)arg2,(XMLCh const *)arg3,(XMLCh const *)arg4);
+  
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  
+  delete[] arg4;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  
+  delete[] arg4;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_removeAttributeNS(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XMLCh *arg3 = (XMLCh *) 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::removeAttributeNS",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::removeAttributeNS",1,"XERCES_CPP_NAMESPACE::DOMElement *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_removeAttributeNS",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  
+  arg3 = Lua2XMLString(3);
+  
+  (arg1)->removeAttributeNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+  
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_getAttributeNodeNS(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XMLCh *arg3 = (XMLCh *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::getAttributeNodeNS",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::getAttributeNodeNS",1,"XERCES_CPP_NAMESPACE::DOMElement const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_getAttributeNodeNS",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  
+  arg3 = Lua2XMLString(3);
+  
+  result = (XERCES_CPP_NAMESPACE::DOMAttr *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getAttributeNodeNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr,0); SWIG_arg++; 
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_setAttributeNodeNS(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMAttr *arg2 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMAttr *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::setAttributeNodeNS",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::setAttributeNodeNS",1,"XERCES_CPP_NAMESPACE::DOMElement *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::setAttributeNodeNS",2,"XERCES_CPP_NAMESPACE::DOMAttr *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_setAttributeNodeNS",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr,0))){
+    SWIG_fail_ptr("DOMElement_setAttributeNodeNS",2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMAttr *)(arg1)->setAttributeNodeNS(arg2);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr,0); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_getElementsByTagNameNS(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XMLCh *arg3 = (XMLCh *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNodeList *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::getElementsByTagNameNS",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::getElementsByTagNameNS",1,"XERCES_CPP_NAMESPACE::DOMElement const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_getElementsByTagNameNS",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  
+  arg3 = Lua2XMLString(3);
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNodeList *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getElementsByTagNameNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList,0); SWIG_arg++; 
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_hasAttribute(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  bool result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::hasAttribute",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::hasAttribute",1,"XERCES_CPP_NAMESPACE::DOMElement const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_hasAttribute",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  result = (bool)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->hasAttribute((XMLCh const *)arg2);
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_hasAttributeNS(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XMLCh *arg3 = (XMLCh *) 0 ;
+  bool result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::hasAttributeNS",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::hasAttributeNS",1,"XERCES_CPP_NAMESPACE::DOMElement const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_hasAttributeNS",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  
+  arg3 = Lua2XMLString(3);
+  
+  result = (bool)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->hasAttributeNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_setIdAttribute(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  bool arg3 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::setIdAttribute",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::setIdAttribute",1,"XERCES_CPP_NAMESPACE::DOMElement *");
+  if(!lua_isboolean(L,3)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::setIdAttribute",3,"bool");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_setIdAttribute",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  arg3 = (lua_toboolean(L, 3)!=0);
+  (arg1)->setIdAttribute((XMLCh const *)arg2,arg3);
+  
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_setIdAttributeNS(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XMLCh *arg3 = (XMLCh *) 0 ;
+  bool arg4 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::setIdAttributeNS",4,4)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::setIdAttributeNS",1,"XERCES_CPP_NAMESPACE::DOMElement *");
+  if(!lua_isboolean(L,4)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::setIdAttributeNS",4,"bool");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_setIdAttributeNS",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  
+  arg3 = Lua2XMLString(3);
+  
+  arg4 = (lua_toboolean(L, 4)!=0);
+  (arg1)->setIdAttributeNS((XMLCh const *)arg2,(XMLCh const *)arg3,arg4);
+  
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_setIdAttributeNode(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMAttr *arg2 = (XERCES_CPP_NAMESPACE::DOMAttr *) 0 ;
+  bool arg3 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::setIdAttributeNode",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::setIdAttributeNode",1,"XERCES_CPP_NAMESPACE::DOMElement *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::setIdAttributeNode",2,"XERCES_CPP_NAMESPACE::DOMAttr const *");
+  if(!lua_isboolean(L,3)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::setIdAttributeNode",3,"bool");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_setIdAttributeNode",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr,0))){
+    SWIG_fail_ptr("DOMElement_setIdAttributeNode",2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMAttr);
+  }
+  
+  arg3 = (lua_toboolean(L, 3)!=0);
+  (arg1)->setIdAttributeNode((XERCES_CPP_NAMESPACE::DOMAttr const *)arg2,arg3);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_getSchemaTypeInfo(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMTypeInfo *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::getSchemaTypeInfo",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::getSchemaTypeInfo",1,"XERCES_CPP_NAMESPACE::DOMElement const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_getSchemaTypeInfo",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMTypeInfo *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getSchemaTypeInfo();
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMTypeInfo,0); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_getFirstElementChild(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::getFirstElementChild",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::getFirstElementChild",1,"XERCES_CPP_NAMESPACE::DOMElement const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_getFirstElementChild",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMElement *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getFirstElementChild();
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_getLastElementChild(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::getLastElementChild",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::getLastElementChild",1,"XERCES_CPP_NAMESPACE::DOMElement const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_getLastElementChild",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMElement *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getLastElementChild();
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_getPreviousElementSibling(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::getPreviousElementSibling",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::getPreviousElementSibling",1,"XERCES_CPP_NAMESPACE::DOMElement const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_getPreviousElementSibling",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMElement *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getPreviousElementSibling();
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_getNextElementSibling(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMElement *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::getNextElementSibling",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::getNextElementSibling",1,"XERCES_CPP_NAMESPACE::DOMElement const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_getNextElementSibling",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMElement *)((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getNextElementSibling();
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMElement_getChildElementCount(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) 0 ;
+  XMLSize_t result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMElement::getChildElementCount",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMElement::getChildElementCount",1,"XERCES_CPP_NAMESPACE::DOMElement const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0))){
+    SWIG_fail_ptr("DOMElement_getChildElementCount",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement);
+  }
+  
+  result = ((XERCES_CPP_NAMESPACE::DOMElement const *)arg1)->getChildElementCount();
+  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static void swig_delete_DOMElement(void *obj) {
+XERCES_CPP_NAMESPACE::DOMElement *arg1 = (XERCES_CPP_NAMESPACE::DOMElement *) obj;
+delete arg1;
+}
+static swig_lua_attribute swig_DOMElement_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_method swig_DOMElement_methods[]= {
+    { "getTagName", _wrap_DOMElement_getTagName},
+    { "getAttribute", _wrap_DOMElement_getAttribute},
+    { "getAttributeNode", _wrap_DOMElement_getAttributeNode},
+    { "getElementsByTagName", _wrap_DOMElement_getElementsByTagName},
+    { "setAttribute", _wrap_DOMElement_setAttribute},
+    { "setAttributeNode", _wrap_DOMElement_setAttributeNode},
+    { "removeAttributeNode", _wrap_DOMElement_removeAttributeNode},
+    { "removeAttribute", _wrap_DOMElement_removeAttribute},
+    { "getAttributeNS", _wrap_DOMElement_getAttributeNS},
+    { "setAttributeNS", _wrap_DOMElement_setAttributeNS},
+    { "removeAttributeNS", _wrap_DOMElement_removeAttributeNS},
+    { "getAttributeNodeNS", _wrap_DOMElement_getAttributeNodeNS},
+    { "setAttributeNodeNS", _wrap_DOMElement_setAttributeNodeNS},
+    { "getElementsByTagNameNS", _wrap_DOMElement_getElementsByTagNameNS},
+    { "hasAttribute", _wrap_DOMElement_hasAttribute},
+    { "hasAttributeNS", _wrap_DOMElement_hasAttributeNS},
+    { "setIdAttribute", _wrap_DOMElement_setIdAttribute},
+    { "setIdAttributeNS", _wrap_DOMElement_setIdAttributeNS},
+    { "setIdAttributeNode", _wrap_DOMElement_setIdAttributeNode},
+    { "getSchemaTypeInfo", _wrap_DOMElement_getSchemaTypeInfo},
+    { "getFirstElementChild", _wrap_DOMElement_getFirstElementChild},
+    { "getLastElementChild", _wrap_DOMElement_getLastElementChild},
+    { "getPreviousElementSibling", _wrap_DOMElement_getPreviousElementSibling},
+    { "getNextElementSibling", _wrap_DOMElement_getNextElementSibling},
+    { "getChildElementCount", _wrap_DOMElement_getChildElementCount},
+    {0,0}
+};
+static swig_lua_method swig_DOMElement_meta[] = {
+    {0,0}
+};
+
+static swig_lua_attribute swig_DOMElement_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_DOMElement_Sf_SwigStatic_constants[]= {
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_DOMElement_Sf_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_DOMElement_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_DOMElement_Sf_SwigStatic = {
+    "DOMElement",
+    swig_DOMElement_Sf_SwigStatic_methods,
+    swig_DOMElement_Sf_SwigStatic_attributes,
+    swig_DOMElement_Sf_SwigStatic_constants,
+    swig_DOMElement_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_DOMElement_bases[] = {0,0};
+static const char *swig_DOMElement_base_names[] = {"XERCES_CPP_NAMESPACE::DOMNode *",0};
+static swig_lua_class _wrap_class_DOMElement = { "DOMElement", "DOMElement", &SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMElement,0, swig_delete_DOMElement, swig_DOMElement_methods, swig_DOMElement_attributes, &swig_DOMElement_Sf_SwigStatic, swig_DOMElement_meta, swig_DOMElement_bases, swig_DOMElement_base_names };
+
+static int _wrap_DOMEntity_getPublicId(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMEntity::getPublicId",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMEntity::getPublicId",1,"XERCES_CPP_NAMESPACE::DOMEntity const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity,0))){
+    SWIG_fail_ptr("DOMEntity_getPublicId",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getPublicId();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMEntity_getSystemId(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMEntity::getSystemId",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMEntity::getSystemId",1,"XERCES_CPP_NAMESPACE::DOMEntity const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity,0))){
+    SWIG_fail_ptr("DOMEntity_getSystemId",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getSystemId();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMEntity_getNotationName(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMEntity::getNotationName",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMEntity::getNotationName",1,"XERCES_CPP_NAMESPACE::DOMEntity const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity,0))){
+    SWIG_fail_ptr("DOMEntity_getNotationName",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getNotationName();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMEntity_getInputEncoding(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMEntity::getInputEncoding",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMEntity::getInputEncoding",1,"XERCES_CPP_NAMESPACE::DOMEntity const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity,0))){
+    SWIG_fail_ptr("DOMEntity_getInputEncoding",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getInputEncoding();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMEntity_getXmlEncoding(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMEntity::getXmlEncoding",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMEntity::getXmlEncoding",1,"XERCES_CPP_NAMESPACE::DOMEntity const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity,0))){
+    SWIG_fail_ptr("DOMEntity_getXmlEncoding",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getXmlEncoding();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMEntity_getXmlVersion(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMEntity::getXmlVersion",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMEntity::getXmlVersion",1,"XERCES_CPP_NAMESPACE::DOMEntity const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity,0))){
+    SWIG_fail_ptr("DOMEntity_getXmlVersion",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMEntity const *)arg1)->getXmlVersion();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static void swig_delete_DOMEntity(void *obj) {
+XERCES_CPP_NAMESPACE::DOMEntity *arg1 = (XERCES_CPP_NAMESPACE::DOMEntity *) obj;
+delete arg1;
+}
+static swig_lua_attribute swig_DOMEntity_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_method swig_DOMEntity_methods[]= {
+    { "getPublicId", _wrap_DOMEntity_getPublicId},
+    { "getSystemId", _wrap_DOMEntity_getSystemId},
+    { "getNotationName", _wrap_DOMEntity_getNotationName},
+    { "getInputEncoding", _wrap_DOMEntity_getInputEncoding},
+    { "getXmlEncoding", _wrap_DOMEntity_getXmlEncoding},
+    { "getXmlVersion", _wrap_DOMEntity_getXmlVersion},
+    {0,0}
+};
+static swig_lua_method swig_DOMEntity_meta[] = {
+    {0,0}
+};
+
+static swig_lua_attribute swig_DOMEntity_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_DOMEntity_Sf_SwigStatic_constants[]= {
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_DOMEntity_Sf_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_DOMEntity_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_DOMEntity_Sf_SwigStatic = {
+    "DOMEntity",
+    swig_DOMEntity_Sf_SwigStatic_methods,
+    swig_DOMEntity_Sf_SwigStatic_attributes,
+    swig_DOMEntity_Sf_SwigStatic_constants,
+    swig_DOMEntity_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_DOMEntity_bases[] = {0,0};
+static const char *swig_DOMEntity_base_names[] = {"XERCES_CPP_NAMESPACE::DOMNode *",0};
+static swig_lua_class _wrap_class_DOMEntity = { "DOMEntity", "DOMEntity", &SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntity,0, swig_delete_DOMEntity, swig_DOMEntity_methods, swig_DOMEntity_attributes, &swig_DOMEntity_Sf_SwigStatic, swig_DOMEntity_meta, swig_DOMEntity_bases, swig_DOMEntity_base_names };
+
+static int _wrap_DOMDocumentType_getName(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMDocumentType::getName",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMDocumentType::getName",1,"XERCES_CPP_NAMESPACE::DOMDocumentType const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType,0))){
+    SWIG_fail_ptr("DOMDocumentType_getName",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getName();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMDocumentType_getEntities(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNamedNodeMap *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMDocumentType::getEntities",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMDocumentType::getEntities",1,"XERCES_CPP_NAMESPACE::DOMDocumentType const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType,0))){
+    SWIG_fail_ptr("DOMDocumentType_getEntities",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getEntities();
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,0); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMDocumentType_getNotations(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNamedNodeMap *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMDocumentType::getNotations",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMDocumentType::getNotations",1,"XERCES_CPP_NAMESPACE::DOMDocumentType const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType,0))){
+    SWIG_fail_ptr("DOMDocumentType_getNotations",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getNotations();
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,0); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMDocumentType_getPublicId(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMDocumentType::getPublicId",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMDocumentType::getPublicId",1,"XERCES_CPP_NAMESPACE::DOMDocumentType const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType,0))){
+    SWIG_fail_ptr("DOMDocumentType_getPublicId",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getPublicId();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMDocumentType_getSystemId(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMDocumentType::getSystemId",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMDocumentType::getSystemId",1,"XERCES_CPP_NAMESPACE::DOMDocumentType const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType,0))){
+    SWIG_fail_ptr("DOMDocumentType_getSystemId",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getSystemId();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMDocumentType_getInternalSubset(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMDocumentType::getInternalSubset",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMDocumentType::getInternalSubset",1,"XERCES_CPP_NAMESPACE::DOMDocumentType const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType,0))){
+    SWIG_fail_ptr("DOMDocumentType_getInternalSubset",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMDocumentType const *)arg1)->getInternalSubset();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static void swig_delete_DOMDocumentType(void *obj) {
+XERCES_CPP_NAMESPACE::DOMDocumentType *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentType *) obj;
+delete arg1;
+}
+static swig_lua_attribute swig_DOMDocumentType_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_method swig_DOMDocumentType_methods[]= {
+    { "getName", _wrap_DOMDocumentType_getName},
+    { "getEntities", _wrap_DOMDocumentType_getEntities},
+    { "getNotations", _wrap_DOMDocumentType_getNotations},
+    { "getPublicId", _wrap_DOMDocumentType_getPublicId},
+    { "getSystemId", _wrap_DOMDocumentType_getSystemId},
+    { "getInternalSubset", _wrap_DOMDocumentType_getInternalSubset},
+    {0,0}
+};
+static swig_lua_method swig_DOMDocumentType_meta[] = {
+    {0,0}
+};
+
+static swig_lua_attribute swig_DOMDocumentType_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_DOMDocumentType_Sf_SwigStatic_constants[]= {
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_DOMDocumentType_Sf_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_DOMDocumentType_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_DOMDocumentType_Sf_SwigStatic = {
+    "DOMDocumentType",
+    swig_DOMDocumentType_Sf_SwigStatic_methods,
+    swig_DOMDocumentType_Sf_SwigStatic_attributes,
+    swig_DOMDocumentType_Sf_SwigStatic_constants,
+    swig_DOMDocumentType_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_DOMDocumentType_bases[] = {0,0};
+static const char *swig_DOMDocumentType_base_names[] = {"XERCES_CPP_NAMESPACE::DOMNode *",0};
+static swig_lua_class _wrap_class_DOMDocumentType = { "DOMDocumentType", "DOMDocumentType", &SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentType,0, swig_delete_DOMDocumentType, swig_DOMDocumentType_methods, swig_DOMDocumentType_attributes, &swig_DOMDocumentType_Sf_SwigStatic, swig_DOMDocumentType_meta, swig_DOMDocumentType_bases, swig_DOMDocumentType_base_names };
+
+static int _wrap_DOMCharacterData_getData(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMCharacterData::getData",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMCharacterData::getData",1,"XERCES_CPP_NAMESPACE::DOMCharacterData const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData,0))){
+    SWIG_fail_ptr("DOMCharacterData_getData",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMCharacterData const *)arg1)->getData();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMCharacterData_getLength(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
+  XMLSize_t result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMCharacterData::getLength",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMCharacterData::getLength",1,"XERCES_CPP_NAMESPACE::DOMCharacterData const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData,0))){
+    SWIG_fail_ptr("DOMCharacterData_getLength",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData);
+  }
+  
+  result = ((XERCES_CPP_NAMESPACE::DOMCharacterData const *)arg1)->getLength();
+  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMCharacterData_substringData(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
+  XMLSize_t arg2 ;
+  XMLSize_t arg3 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMCharacterData::substringData",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMCharacterData::substringData",1,"XERCES_CPP_NAMESPACE::DOMCharacterData const *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMCharacterData::substringData",2,"XMLSize_t");
+  if(!lua_isnumber(L,3)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMCharacterData::substringData",3,"XMLSize_t");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData,0))){
+    SWIG_fail_ptr("DOMCharacterData_substringData",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData);
+  }
+  
+  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
+  arg2 = (XMLSize_t)lua_tonumber(L, 2);
+  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
+  arg3 = (XMLSize_t)lua_tonumber(L, 3);
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMCharacterData const *)arg1)->substringData(arg2,arg3);
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMCharacterData_appendData(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMCharacterData::appendData",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMCharacterData::appendData",1,"XERCES_CPP_NAMESPACE::DOMCharacterData *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData,0))){
+    SWIG_fail_ptr("DOMCharacterData_appendData",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  (arg1)->appendData((XMLCh const *)arg2);
+  
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMCharacterData_insertData(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
+  XMLSize_t arg2 ;
+  XMLCh *arg3 = (XMLCh *) 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMCharacterData::insertData",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMCharacterData::insertData",1,"XERCES_CPP_NAMESPACE::DOMCharacterData *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMCharacterData::insertData",2,"XMLSize_t");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData,0))){
+    SWIG_fail_ptr("DOMCharacterData_insertData",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData);
+  }
+  
+  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
+  arg2 = (XMLSize_t)lua_tonumber(L, 2);
+  
+  arg3 = Lua2XMLString(3);
+  
+  (arg1)->insertData(arg2,(XMLCh const *)arg3);
+  
+  
+  delete[] arg3;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg3;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMCharacterData_deleteData(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
+  XMLSize_t arg2 ;
+  XMLSize_t arg3 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMCharacterData::deleteData",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMCharacterData::deleteData",1,"XERCES_CPP_NAMESPACE::DOMCharacterData *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMCharacterData::deleteData",2,"XMLSize_t");
+  if(!lua_isnumber(L,3)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMCharacterData::deleteData",3,"XMLSize_t");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData,0))){
+    SWIG_fail_ptr("DOMCharacterData_deleteData",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData);
+  }
+  
+  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
+  arg2 = (XMLSize_t)lua_tonumber(L, 2);
+  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
+  arg3 = (XMLSize_t)lua_tonumber(L, 3);
+  (arg1)->deleteData(arg2,arg3);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMCharacterData_replaceData(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
+  XMLSize_t arg2 ;
+  XMLSize_t arg3 ;
+  XMLCh *arg4 = (XMLCh *) 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMCharacterData::replaceData",4,4)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMCharacterData::replaceData",1,"XERCES_CPP_NAMESPACE::DOMCharacterData *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMCharacterData::replaceData",2,"XMLSize_t");
+  if(!lua_isnumber(L,3)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMCharacterData::replaceData",3,"XMLSize_t");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData,0))){
+    SWIG_fail_ptr("DOMCharacterData_replaceData",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData);
+  }
+  
+  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
+  arg2 = (XMLSize_t)lua_tonumber(L, 2);
+  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
+  arg3 = (XMLSize_t)lua_tonumber(L, 3);
+  
+  arg4 = Lua2XMLString(4);
+  
+  (arg1)->replaceData(arg2,arg3,(XMLCh const *)arg4);
+  
+  
+  delete[] arg4;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg4;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMCharacterData_setData(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMCharacterData::setData",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMCharacterData::setData",1,"XERCES_CPP_NAMESPACE::DOMCharacterData *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData,0))){
+    SWIG_fail_ptr("DOMCharacterData_setData",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  (arg1)->setData((XMLCh const *)arg2);
+  
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static void swig_delete_DOMCharacterData(void *obj) {
+XERCES_CPP_NAMESPACE::DOMCharacterData *arg1 = (XERCES_CPP_NAMESPACE::DOMCharacterData *) obj;
+delete arg1;
+}
+static swig_lua_attribute swig_DOMCharacterData_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_method swig_DOMCharacterData_methods[]= {
+    { "getData", _wrap_DOMCharacterData_getData},
+    { "getLength", _wrap_DOMCharacterData_getLength},
+    { "substringData", _wrap_DOMCharacterData_substringData},
+    { "appendData", _wrap_DOMCharacterData_appendData},
+    { "insertData", _wrap_DOMCharacterData_insertData},
+    { "deleteData", _wrap_DOMCharacterData_deleteData},
+    { "replaceData", _wrap_DOMCharacterData_replaceData},
+    { "setData", _wrap_DOMCharacterData_setData},
+    {0,0}
+};
+static swig_lua_method swig_DOMCharacterData_meta[] = {
+    {0,0}
+};
+
+static swig_lua_attribute swig_DOMCharacterData_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_DOMCharacterData_Sf_SwigStatic_constants[]= {
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_DOMCharacterData_Sf_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_DOMCharacterData_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_DOMCharacterData_Sf_SwigStatic = {
+    "DOMCharacterData",
+    swig_DOMCharacterData_Sf_SwigStatic_methods,
+    swig_DOMCharacterData_Sf_SwigStatic_attributes,
+    swig_DOMCharacterData_Sf_SwigStatic_constants,
+    swig_DOMCharacterData_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_DOMCharacterData_bases[] = {0,0};
+static const char *swig_DOMCharacterData_base_names[] = {"XERCES_CPP_NAMESPACE::DOMNode *",0};
+static swig_lua_class _wrap_class_DOMCharacterData = { "DOMCharacterData", "DOMCharacterData", &SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCharacterData,0, swig_delete_DOMCharacterData, swig_DOMCharacterData_methods, swig_DOMCharacterData_attributes, &swig_DOMCharacterData_Sf_SwigStatic, swig_DOMCharacterData_meta, swig_DOMCharacterData_bases, swig_DOMCharacterData_base_names };
+
+static void swig_delete_DOMComment(void *obj) {
+XERCES_CPP_NAMESPACE::DOMComment *arg1 = (XERCES_CPP_NAMESPACE::DOMComment *) obj;
+delete arg1;
+}
+static swig_lua_attribute swig_DOMComment_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_method swig_DOMComment_methods[]= {
+    {0,0}
+};
+static swig_lua_method swig_DOMComment_meta[] = {
+    {0,0}
+};
+
+static swig_lua_attribute swig_DOMComment_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_DOMComment_Sf_SwigStatic_constants[]= {
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_DOMComment_Sf_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_DOMComment_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_DOMComment_Sf_SwigStatic = {
+    "DOMComment",
+    swig_DOMComment_Sf_SwigStatic_methods,
+    swig_DOMComment_Sf_SwigStatic_attributes,
+    swig_DOMComment_Sf_SwigStatic_constants,
+    swig_DOMComment_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_DOMComment_bases[] = {0,0};
+static const char *swig_DOMComment_base_names[] = {"XERCES_CPP_NAMESPACE::DOMCharacterData *",0};
+static swig_lua_class _wrap_class_DOMComment = { "DOMComment", "DOMComment", &SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMComment,0, swig_delete_DOMComment, swig_DOMComment_methods, swig_DOMComment_attributes, &swig_DOMComment_Sf_SwigStatic, swig_DOMComment_meta, swig_DOMComment_bases, swig_DOMComment_base_names };
+
+static int _wrap_DOMText_splitText(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) 0 ;
+  XMLSize_t arg2 ;
+  XERCES_CPP_NAMESPACE::DOMText *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMText::splitText",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMText::splitText",1,"XERCES_CPP_NAMESPACE::DOMText *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMText::splitText",2,"XMLSize_t");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText,0))){
+    SWIG_fail_ptr("DOMText_splitText",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText);
+  }
+  
+  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
+  arg2 = (XMLSize_t)lua_tonumber(L, 2);
+  result = (XERCES_CPP_NAMESPACE::DOMText *)(arg1)->splitText(arg2);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText,0); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMText_getIsElementContentWhitespace(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) 0 ;
+  bool result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMText::getIsElementContentWhitespace",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMText::getIsElementContentWhitespace",1,"XERCES_CPP_NAMESPACE::DOMText const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText,0))){
+    SWIG_fail_ptr("DOMText_getIsElementContentWhitespace",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText);
+  }
+  
+  result = (bool)((XERCES_CPP_NAMESPACE::DOMText const *)arg1)->getIsElementContentWhitespace();
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMText_getWholeText(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMText::getWholeText",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMText::getWholeText",1,"XERCES_CPP_NAMESPACE::DOMText const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText,0))){
+    SWIG_fail_ptr("DOMText_getWholeText",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMText const *)arg1)->getWholeText();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMText_replaceWholeText(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMText *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMText::replaceWholeText",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMText::replaceWholeText",1,"XERCES_CPP_NAMESPACE::DOMText *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText,0))){
+    SWIG_fail_ptr("DOMText_replaceWholeText",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  result = (XERCES_CPP_NAMESPACE::DOMText *)(arg1)->replaceWholeText((XMLCh const *)arg2);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText,0); SWIG_arg++; 
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMText_isIgnorableWhitespace(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) 0 ;
+  bool result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMText::isIgnorableWhitespace",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMText::isIgnorableWhitespace",1,"XERCES_CPP_NAMESPACE::DOMText const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText,0))){
+    SWIG_fail_ptr("DOMText_isIgnorableWhitespace",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText);
+  }
+  
+  result = (bool)((XERCES_CPP_NAMESPACE::DOMText const *)arg1)->isIgnorableWhitespace();
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static void swig_delete_DOMText(void *obj) {
+XERCES_CPP_NAMESPACE::DOMText *arg1 = (XERCES_CPP_NAMESPACE::DOMText *) obj;
+delete arg1;
+}
+static swig_lua_attribute swig_DOMText_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_method swig_DOMText_methods[]= {
+    { "splitText", _wrap_DOMText_splitText},
+    { "getIsElementContentWhitespace", _wrap_DOMText_getIsElementContentWhitespace},
+    { "getWholeText", _wrap_DOMText_getWholeText},
+    { "replaceWholeText", _wrap_DOMText_replaceWholeText},
+    { "isIgnorableWhitespace", _wrap_DOMText_isIgnorableWhitespace},
+    {0,0}
+};
+static swig_lua_method swig_DOMText_meta[] = {
+    {0,0}
+};
+
+static swig_lua_attribute swig_DOMText_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_DOMText_Sf_SwigStatic_constants[]= {
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_DOMText_Sf_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_DOMText_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_DOMText_Sf_SwigStatic = {
+    "DOMText",
+    swig_DOMText_Sf_SwigStatic_methods,
+    swig_DOMText_Sf_SwigStatic_attributes,
+    swig_DOMText_Sf_SwigStatic_constants,
+    swig_DOMText_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_DOMText_bases[] = {0,0};
+static const char *swig_DOMText_base_names[] = {"XERCES_CPP_NAMESPACE::DOMCharacterData *",0};
+static swig_lua_class _wrap_class_DOMText = { "DOMText", "DOMText", &SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMText,0, swig_delete_DOMText, swig_DOMText_methods, swig_DOMText_attributes, &swig_DOMText_Sf_SwigStatic, swig_DOMText_meta, swig_DOMText_bases, swig_DOMText_base_names };
+
+static void swig_delete_DOMCDATASection(void *obj) {
+XERCES_CPP_NAMESPACE::DOMCDATASection *arg1 = (XERCES_CPP_NAMESPACE::DOMCDATASection *) obj;
+delete arg1;
+}
+static swig_lua_attribute swig_DOMCDATASection_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_method swig_DOMCDATASection_methods[]= {
+    {0,0}
+};
+static swig_lua_method swig_DOMCDATASection_meta[] = {
+    {0,0}
+};
+
+static swig_lua_attribute swig_DOMCDATASection_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_DOMCDATASection_Sf_SwigStatic_constants[]= {
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_DOMCDATASection_Sf_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_DOMCDATASection_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_DOMCDATASection_Sf_SwigStatic = {
+    "DOMCDATASection",
+    swig_DOMCDATASection_Sf_SwigStatic_methods,
+    swig_DOMCDATASection_Sf_SwigStatic_attributes,
+    swig_DOMCDATASection_Sf_SwigStatic_constants,
+    swig_DOMCDATASection_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_DOMCDATASection_bases[] = {0,0};
+static const char *swig_DOMCDATASection_base_names[] = {"XERCES_CPP_NAMESPACE::DOMText *",0};
+static swig_lua_class _wrap_class_DOMCDATASection = { "DOMCDATASection", "DOMCDATASection", &SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMCDATASection,0, swig_delete_DOMCDATASection, swig_DOMCDATASection_methods, swig_DOMCDATASection_attributes, &swig_DOMCDATASection_Sf_SwigStatic, swig_DOMCDATASection_meta, swig_DOMCDATASection_bases, swig_DOMCDATASection_base_names };
+
+static int _wrap_DOMNodeList_item(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNodeList *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeList *) 0 ;
+  XMLSize_t arg2 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNodeList::item",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNodeList::item",1,"XERCES_CPP_NAMESPACE::DOMNodeList const *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNodeList::item",2,"XMLSize_t");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList,0))){
+    SWIG_fail_ptr("DOMNodeList_item",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList);
+  }
+  
+  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
+  arg2 = (XMLSize_t)lua_tonumber(L, 2);
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNodeList const *)arg1)->item(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNodeList_getLength(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNodeList *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeList *) 0 ;
+  XMLSize_t result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNodeList::getLength",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNodeList::getLength",1,"XERCES_CPP_NAMESPACE::DOMNodeList const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList,0))){
+    SWIG_fail_ptr("DOMNodeList_getLength",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList);
+  }
+  
+  result = ((XERCES_CPP_NAMESPACE::DOMNodeList const *)arg1)->getLength();
+  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static void swig_delete_DOMNodeList(void *obj) {
+XERCES_CPP_NAMESPACE::DOMNodeList *arg1 = (XERCES_CPP_NAMESPACE::DOMNodeList *) obj;
+delete arg1;
+}
+static swig_lua_attribute swig_DOMNodeList_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_method swig_DOMNodeList_methods[]= {
+    { "item", _wrap_DOMNodeList_item},
+    { "getLength", _wrap_DOMNodeList_getLength},
+    {0,0}
+};
+static swig_lua_method swig_DOMNodeList_meta[] = {
+    {0,0}
+};
+
+static swig_lua_attribute swig_DOMNodeList_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_DOMNodeList_Sf_SwigStatic_constants[]= {
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_DOMNodeList_Sf_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_DOMNodeList_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_DOMNodeList_Sf_SwigStatic = {
+    "DOMNodeList",
+    swig_DOMNodeList_Sf_SwigStatic_methods,
+    swig_DOMNodeList_Sf_SwigStatic_attributes,
+    swig_DOMNodeList_Sf_SwigStatic_constants,
+    swig_DOMNodeList_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_DOMNodeList_bases[] = {0};
+static const char *swig_DOMNodeList_base_names[] = {0};
+static swig_lua_class _wrap_class_DOMNodeList = { "DOMNodeList", "DOMNodeList", &SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNodeList,0, swig_delete_DOMNodeList, swig_DOMNodeList_methods, swig_DOMNodeList_attributes, &swig_DOMNodeList_Sf_SwigStatic, swig_DOMNodeList_meta, swig_DOMNodeList_bases, swig_DOMNodeList_base_names };
+
+static int _wrap_DOMNamedNodeMap_setNamedItem(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::setNamedItem",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::setNamedItem",1,"XERCES_CPP_NAMESPACE::DOMNamedNodeMap *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::setNamedItem",2,"XERCES_CPP_NAMESPACE::DOMNode *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,0))){
+    SWIG_fail_ptr("DOMNamedNodeMap_setNamedItem",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNamedNodeMap_setNamedItem",2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->setNamedItem(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNamedNodeMap_item(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+  XMLSize_t arg2 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::item",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::item",1,"XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::item",2,"XMLSize_t");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,0))){
+    SWIG_fail_ptr("DOMNamedNodeMap_item",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap);
+  }
+  
+  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
+  arg2 = (XMLSize_t)lua_tonumber(L, 2);
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *)arg1)->item(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNamedNodeMap_getNamedItem(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::getNamedItem",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::getNamedItem",1,"XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,0))){
+    SWIG_fail_ptr("DOMNamedNodeMap_getNamedItem",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *)arg1)->getNamedItem((XMLCh const *)arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNamedNodeMap_getLength(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+  XMLSize_t result;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::getLength",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::getLength",1,"XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,0))){
+    SWIG_fail_ptr("DOMNamedNodeMap_getLength",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap);
+  }
+  
+  result = ((XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *)arg1)->getLength();
+  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNamedNodeMap_removeNamedItem(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::removeNamedItem",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::removeNamedItem",1,"XERCES_CPP_NAMESPACE::DOMNamedNodeMap *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,0))){
+    SWIG_fail_ptr("DOMNamedNodeMap_removeNamedItem",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->removeNamedItem((XMLCh const *)arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNamedNodeMap_getNamedItemNS(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XMLCh *arg3 = (XMLCh *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::getNamedItemNS",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::getNamedItemNS",1,"XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,0))){
+    SWIG_fail_ptr("DOMNamedNodeMap_getNamedItemNS",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  
+  arg3 = Lua2XMLString(3);
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)((XERCES_CPP_NAMESPACE::DOMNamedNodeMap const *)arg1)->getNamedItemNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNamedNodeMap_setNamedItemNS(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *arg2 = (XERCES_CPP_NAMESPACE::DOMNode *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::setNamedItemNS",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::setNamedItemNS",1,"XERCES_CPP_NAMESPACE::DOMNamedNodeMap *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::setNamedItemNS",2,"XERCES_CPP_NAMESPACE::DOMNode *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,0))){
+    SWIG_fail_ptr("DOMNamedNodeMap_setNamedItemNS",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,0))){
+    SWIG_fail_ptr("DOMNamedNodeMap_setNamedItemNS",2,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode);
+  }
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->setNamedItemNS(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNamedNodeMap_removeNamedItemNS(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  XMLCh *arg3 = (XMLCh *) 0 ;
+  XERCES_CPP_NAMESPACE::DOMNode *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::removeNamedItemNS",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNamedNodeMap::removeNamedItemNS",1,"XERCES_CPP_NAMESPACE::DOMNamedNodeMap *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,0))){
+    SWIG_fail_ptr("DOMNamedNodeMap_removeNamedItemNS",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  
+  arg3 = Lua2XMLString(3);
+  
+  result = (XERCES_CPP_NAMESPACE::DOMNode *)(arg1)->removeNamedItemNS((XMLCh const *)arg2,(XMLCh const *)arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode, (void **) &result);
+    SWIG_NewPointerObj(L,(void*)result,ty,0); SWIG_arg++; 
+  }
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  
+  delete[] arg3;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static void swig_delete_DOMNamedNodeMap(void *obj) {
+XERCES_CPP_NAMESPACE::DOMNamedNodeMap *arg1 = (XERCES_CPP_NAMESPACE::DOMNamedNodeMap *) obj;
+delete arg1;
+}
+static swig_lua_attribute swig_DOMNamedNodeMap_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_method swig_DOMNamedNodeMap_methods[]= {
+    { "setNamedItem", _wrap_DOMNamedNodeMap_setNamedItem},
+    { "item", _wrap_DOMNamedNodeMap_item},
+    { "getNamedItem", _wrap_DOMNamedNodeMap_getNamedItem},
+    { "getLength", _wrap_DOMNamedNodeMap_getLength},
+    { "removeNamedItem", _wrap_DOMNamedNodeMap_removeNamedItem},
+    { "getNamedItemNS", _wrap_DOMNamedNodeMap_getNamedItemNS},
+    { "setNamedItemNS", _wrap_DOMNamedNodeMap_setNamedItemNS},
+    { "removeNamedItemNS", _wrap_DOMNamedNodeMap_removeNamedItemNS},
+    {0,0}
+};
+static swig_lua_method swig_DOMNamedNodeMap_meta[] = {
+    {0,0}
+};
+
+static swig_lua_attribute swig_DOMNamedNodeMap_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_DOMNamedNodeMap_SwigStatic_constants[]= {
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_DOMNamedNodeMap_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_DOMNamedNodeMap_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_DOMNamedNodeMap_SwigStatic = {
+    "DOMNamedNodeMap",
+    swig_DOMNamedNodeMap_SwigStatic_methods,
+    swig_DOMNamedNodeMap_SwigStatic_attributes,
+    swig_DOMNamedNodeMap_SwigStatic_constants,
+    swig_DOMNamedNodeMap_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_DOMNamedNodeMap_bases[] = {0};
+static const char *swig_DOMNamedNodeMap_base_names[] = {0};
+static swig_lua_class _wrap_class_DOMNamedNodeMap = { "DOMNamedNodeMap", "DOMNamedNodeMap", &SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,0, swig_delete_DOMNamedNodeMap, swig_DOMNamedNodeMap_methods, swig_DOMNamedNodeMap_attributes, &swig_DOMNamedNodeMap_SwigStatic, swig_DOMNamedNodeMap_meta, swig_DOMNamedNodeMap_bases, swig_DOMNamedNodeMap_base_names };
+
+static void swig_delete_DOMDocumentFragment(void *obj) {
+XERCES_CPP_NAMESPACE::DOMDocumentFragment *arg1 = (XERCES_CPP_NAMESPACE::DOMDocumentFragment *) obj;
+delete arg1;
+}
+static swig_lua_attribute swig_DOMDocumentFragment_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_method swig_DOMDocumentFragment_methods[]= {
+    {0,0}
+};
+static swig_lua_method swig_DOMDocumentFragment_meta[] = {
+    {0,0}
+};
+
+static swig_lua_attribute swig_DOMDocumentFragment_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_DOMDocumentFragment_Sf_SwigStatic_constants[]= {
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_DOMDocumentFragment_Sf_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_DOMDocumentFragment_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_DOMDocumentFragment_Sf_SwigStatic = {
+    "DOMDocumentFragment",
+    swig_DOMDocumentFragment_Sf_SwigStatic_methods,
+    swig_DOMDocumentFragment_Sf_SwigStatic_attributes,
+    swig_DOMDocumentFragment_Sf_SwigStatic_constants,
+    swig_DOMDocumentFragment_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_DOMDocumentFragment_bases[] = {0,0};
+static const char *swig_DOMDocumentFragment_base_names[] = {"XERCES_CPP_NAMESPACE::DOMNode *",0};
+static swig_lua_class _wrap_class_DOMDocumentFragment = { "DOMDocumentFragment", "DOMDocumentFragment", &SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMDocumentFragment,0, swig_delete_DOMDocumentFragment, swig_DOMDocumentFragment_methods, swig_DOMDocumentFragment_attributes, &swig_DOMDocumentFragment_Sf_SwigStatic, swig_DOMDocumentFragment_meta, swig_DOMDocumentFragment_bases, swig_DOMDocumentFragment_base_names };
+
+static void swig_delete_DOMEntityReference(void *obj) {
+XERCES_CPP_NAMESPACE::DOMEntityReference *arg1 = (XERCES_CPP_NAMESPACE::DOMEntityReference *) obj;
+delete arg1;
+}
+static swig_lua_attribute swig_DOMEntityReference_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_method swig_DOMEntityReference_methods[]= {
+    {0,0}
+};
+static swig_lua_method swig_DOMEntityReference_meta[] = {
+    {0,0}
+};
+
+static swig_lua_attribute swig_DOMEntityReference_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_DOMEntityReference_Sf_SwigStatic_constants[]= {
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_DOMEntityReference_Sf_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_DOMEntityReference_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_DOMEntityReference_Sf_SwigStatic = {
+    "DOMEntityReference",
+    swig_DOMEntityReference_Sf_SwigStatic_methods,
+    swig_DOMEntityReference_Sf_SwigStatic_attributes,
+    swig_DOMEntityReference_Sf_SwigStatic_constants,
+    swig_DOMEntityReference_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_DOMEntityReference_bases[] = {0,0};
+static const char *swig_DOMEntityReference_base_names[] = {"XERCES_CPP_NAMESPACE::DOMNode *",0};
+static swig_lua_class _wrap_class_DOMEntityReference = { "DOMEntityReference", "DOMEntityReference", &SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMEntityReference,0, swig_delete_DOMEntityReference, swig_DOMEntityReference_methods, swig_DOMEntityReference_attributes, &swig_DOMEntityReference_Sf_SwigStatic, swig_DOMEntityReference_meta, swig_DOMEntityReference_bases, swig_DOMEntityReference_base_names };
+
+static int _wrap_DOMNotation_getPublicId(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNotation *arg1 = (XERCES_CPP_NAMESPACE::DOMNotation *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNotation::getPublicId",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNotation::getPublicId",1,"XERCES_CPP_NAMESPACE::DOMNotation const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation,0))){
+    SWIG_fail_ptr("DOMNotation_getPublicId",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNotation const *)arg1)->getPublicId();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMNotation_getSystemId(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMNotation *arg1 = (XERCES_CPP_NAMESPACE::DOMNotation *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMNotation::getSystemId",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMNotation::getSystemId",1,"XERCES_CPP_NAMESPACE::DOMNotation const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation,0))){
+    SWIG_fail_ptr("DOMNotation_getSystemId",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMNotation const *)arg1)->getSystemId();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static void swig_delete_DOMNotation(void *obj) {
+XERCES_CPP_NAMESPACE::DOMNotation *arg1 = (XERCES_CPP_NAMESPACE::DOMNotation *) obj;
+delete arg1;
+}
+static swig_lua_attribute swig_DOMNotation_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_method swig_DOMNotation_methods[]= {
+    { "getPublicId", _wrap_DOMNotation_getPublicId},
+    { "getSystemId", _wrap_DOMNotation_getSystemId},
+    {0,0}
+};
+static swig_lua_method swig_DOMNotation_meta[] = {
+    {0,0}
+};
+
+static swig_lua_attribute swig_DOMNotation_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_DOMNotation_Sf_SwigStatic_constants[]= {
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_DOMNotation_Sf_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_DOMNotation_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_DOMNotation_Sf_SwigStatic = {
+    "DOMNotation",
+    swig_DOMNotation_Sf_SwigStatic_methods,
+    swig_DOMNotation_Sf_SwigStatic_attributes,
+    swig_DOMNotation_Sf_SwigStatic_constants,
+    swig_DOMNotation_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_DOMNotation_bases[] = {0,0};
+static const char *swig_DOMNotation_base_names[] = {"XERCES_CPP_NAMESPACE::DOMNode *",0};
+static swig_lua_class _wrap_class_DOMNotation = { "DOMNotation", "DOMNotation", &SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNotation,0, swig_delete_DOMNotation, swig_DOMNotation_methods, swig_DOMNotation_attributes, &swig_DOMNotation_Sf_SwigStatic, swig_DOMNotation_meta, swig_DOMNotation_bases, swig_DOMNotation_base_names };
+
+static int _wrap_DOMProcessingInstruction_getTarget(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMProcessingInstruction *arg1 = (XERCES_CPP_NAMESPACE::DOMProcessingInstruction *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMProcessingInstruction::getTarget",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMProcessingInstruction::getTarget",1,"XERCES_CPP_NAMESPACE::DOMProcessingInstruction const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction,0))){
+    SWIG_fail_ptr("DOMProcessingInstruction_getTarget",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMProcessingInstruction const *)arg1)->getTarget();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMProcessingInstruction_getData(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMProcessingInstruction *arg1 = (XERCES_CPP_NAMESPACE::DOMProcessingInstruction *) 0 ;
+  XMLCh *result = 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMProcessingInstruction::getData",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMProcessingInstruction::getData",1,"XERCES_CPP_NAMESPACE::DOMProcessingInstruction const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction,0))){
+    SWIG_fail_ptr("DOMProcessingInstruction_getData",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction);
+  }
+  
+  result = (XMLCh *)((XERCES_CPP_NAMESPACE::DOMProcessingInstruction const *)arg1)->getData();
+  
+  result = XMLString2Lua(result);
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_DOMProcessingInstruction_setData(lua_State* L) {
+  int SWIG_arg = 0;
+  XERCES_CPP_NAMESPACE::DOMProcessingInstruction *arg1 = (XERCES_CPP_NAMESPACE::DOMProcessingInstruction *) 0 ;
+  XMLCh *arg2 = (XMLCh *) 0 ;
+  
+  SWIG_check_num_args("XERCES_CPP_NAMESPACE::DOMProcessingInstruction::setData",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("XERCES_CPP_NAMESPACE::DOMProcessingInstruction::setData",1,"XERCES_CPP_NAMESPACE::DOMProcessingInstruction *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction,0))){
+    SWIG_fail_ptr("DOMProcessingInstruction_setData",1,SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction);
+  }
+  
+  
+  arg2 = Lua2XMLString(2);
+  
+  (arg1)->setData((XMLCh const *)arg2);
+  
+  
+  delete[] arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  
+  delete[] arg2;
+  
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static void swig_delete_DOMProcessingInstruction(void *obj) {
+XERCES_CPP_NAMESPACE::DOMProcessingInstruction *arg1 = (XERCES_CPP_NAMESPACE::DOMProcessingInstruction *) obj;
+delete arg1;
+}
+static swig_lua_attribute swig_DOMProcessingInstruction_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_method swig_DOMProcessingInstruction_methods[]= {
+    { "getTarget", _wrap_DOMProcessingInstruction_getTarget},
+    { "getData", _wrap_DOMProcessingInstruction_getData},
+    { "setData", _wrap_DOMProcessingInstruction_setData},
+    {0,0}
+};
+static swig_lua_method swig_DOMProcessingInstruction_meta[] = {
+    {0,0}
+};
+
+static swig_lua_attribute swig_DOMProcessingInstruction_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_DOMProcessingInstruction_Sf_SwigStatic_constants[]= {
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_DOMProcessingInstruction_Sf_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_DOMProcessingInstruction_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_DOMProcessingInstruction_Sf_SwigStatic = {
+    "DOMProcessingInstruction",
+    swig_DOMProcessingInstruction_Sf_SwigStatic_methods,
+    swig_DOMProcessingInstruction_Sf_SwigStatic_attributes,
+    swig_DOMProcessingInstruction_Sf_SwigStatic_constants,
+    swig_DOMProcessingInstruction_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_DOMProcessingInstruction_bases[] = {0,0};
+static const char *swig_DOMProcessingInstruction_base_names[] = {"XERCES_CPP_NAMESPACE::DOMNode *",0};
+static swig_lua_class _wrap_class_DOMProcessingInstruction = { "DOMProcessingInstruction", "DOMProcessingInstruction", &SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction,0, swig_delete_DOMProcessingInstruction, swig_DOMProcessingInstruction_methods, swig_DOMProcessingInstruction_attributes, &swig_DOMProcessingInstruction_Sf_SwigStatic, swig_DOMProcessingInstruction_meta, swig_DOMProcessingInstruction_bases, swig_DOMProcessingInstruction_base_names };
+
+static int _wrap_new_Event__SWIG_0(lua_State* L) {
+  int SWIG_arg = 0;
+  uscxml::Event *result = 0 ;
+  
+  SWIG_check_num_args("uscxml::Event::Event",0,0)
+  result = (uscxml::Event *)new uscxml::Event();
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_uscxml__Event,1); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_new_Event__SWIG_1(lua_State* L) {
+  int SWIG_arg = 0;
+  std::string *arg1 = 0 ;
+  uscxml::Event::Type arg2 ;
+  std::string temp1 ;
+  uscxml::Event *result = 0 ;
+  
+  SWIG_check_num_args("uscxml::Event::Event",2,2)
+  if(!lua_isstring(L,1)) SWIG_fail_arg("uscxml::Event::Event",1,"std::string const &");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("uscxml::Event::Event",2,"uscxml::Event::Type");
+  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
+  arg2 = (uscxml::Event::Type)(int)lua_tonumber(L, 2);
+  result = (uscxml::Event *)new uscxml::Event((std::string const &)*arg1,arg2);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_uscxml__Event,1); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_new_Event__SWIG_2(lua_State* L) {
+  int SWIG_arg = 0;
+  std::string *arg1 = 0 ;
+  std::string temp1 ;
+  uscxml::Event *result = 0 ;
+  
+  SWIG_check_num_args("uscxml::Event::Event",1,1)
+  if(!lua_isstring(L,1)) SWIG_fail_arg("uscxml::Event::Event",1,"std::string const &");
+  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
+  result = (uscxml::Event *)new uscxml::Event((std::string const &)*arg1);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_uscxml__Event,1); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_new_Event(lua_State* L) {
+  int argc;
+  int argv[3]={
+    1,2,3
+  };
+  
+  argc = lua_gettop(L);
+  if (argc == 0) {
+    return _wrap_new_Event__SWIG_0(L);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      _v = lua_isstring(L,argv[0]);
+    }
+    if (_v) {
+      return _wrap_new_Event__SWIG_2(L);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      _v = lua_isstring(L,argv[0]);
+    }
+    if (_v) {
+      {
+        _v = lua_isnumber(L,argv[1]);
+      }
+      if (_v) {
+        return _wrap_new_Event__SWIG_1(L);
+      }
+    }
+  }
+  
+  SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Event'\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    uscxml::Event::Event()\n"
+    "    uscxml::Event::Event(std::string const &,uscxml::Event::Type)\n"
+    "    uscxml::Event::Event(std::string const &)\n");
+  lua_error(L);return 0;
+}
+
+
+static int _wrap_Event___lt(lua_State* L) {
+  int SWIG_arg = 0;
+  uscxml::Event *arg1 = (uscxml::Event *) 0 ;
+  uscxml::Event *arg2 = 0 ;
+  bool result;
+  
+  SWIG_check_num_args("uscxml::Event::operator <",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("uscxml::Event::operator <",1,"uscxml::Event const *");
+  if(!lua_isuserdata(L,2)) SWIG_fail_arg("uscxml::Event::operator <",2,"uscxml::Event const &");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_uscxml__Event,0))){
+    SWIG_fail_ptr("Event___lt",1,SWIGTYPE_p_uscxml__Event);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_uscxml__Event,0))){
+    SWIG_fail_ptr("Event___lt",2,SWIGTYPE_p_uscxml__Event);
+  }
+  
+  result = (bool)((uscxml::Event const *)arg1)->operator <((uscxml::Event const &)*arg2);
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_Event___eq(lua_State* L) {
+  int SWIG_arg = 0;
+  uscxml::Event *arg1 = (uscxml::Event *) 0 ;
+  uscxml::Event *arg2 = 0 ;
+  bool result;
+  
+  SWIG_check_num_args("uscxml::Event::operator ==",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("uscxml::Event::operator ==",1,"uscxml::Event const *");
+  if(!lua_isuserdata(L,2)) SWIG_fail_arg("uscxml::Event::operator ==",2,"uscxml::Event const &");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_uscxml__Event,0))){
+    SWIG_fail_ptr("Event___eq",1,SWIGTYPE_p_uscxml__Event);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_uscxml__Event,0))){
+    SWIG_fail_ptr("Event___eq",2,SWIGTYPE_p_uscxml__Event);
+  }
+  
+  result = (bool)((uscxml::Event const *)arg1)->operator ==((uscxml::Event const &)*arg2);
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_Event_getParam__SWIG_0(lua_State* L) {
+  int SWIG_arg = 0;
+  uscxml::Event::params_t *arg1 = 0 ;
+  std::string *arg2 = 0 ;
+  Data *arg3 = 0 ;
+  std::string temp2 ;
+  bool result;
+  
+  SWIG_check_num_args("uscxml::Event::getParam",3,3)
+  if(!lua_isuserdata(L,1)) SWIG_fail_arg("uscxml::Event::getParam",1,"uscxml::Event::params_t const &");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("uscxml::Event::getParam",2,"std::string const &");
+  if(!lua_isuserdata(L,3)) SWIG_fail_arg("uscxml::Event::getParam",3,"Data &");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__multimapT_std__string_Data_t,0))){
+    SWIG_fail_ptr("Event_getParam",1,SWIGTYPE_p_std__multimapT_std__string_Data_t);
+  }
+  
+  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Data,0))){
+    SWIG_fail_ptr("Event_getParam",3,SWIGTYPE_p_Data);
+  }
+  
+  result = (bool)uscxml::Event::getParam((std::multimap< std::string,Data > const &)*arg1,(std::string const &)*arg2,*arg3);
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_Event_getParam__SWIG_1(lua_State* L) {
+  int SWIG_arg = 0;
+  uscxml::Event::params_t *arg1 = 0 ;
+  std::string *arg2 = 0 ;
+  std::list< Data > *arg3 = 0 ;
+  std::string temp2 ;
+  bool result;
+  
+  SWIG_check_num_args("uscxml::Event::getParam",3,3)
+  if(!lua_isuserdata(L,1)) SWIG_fail_arg("uscxml::Event::getParam",1,"uscxml::Event::params_t const &");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("uscxml::Event::getParam",2,"std::string const &");
+  if(!lua_isuserdata(L,3)) SWIG_fail_arg("uscxml::Event::getParam",3,"std::list< Data > &");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__multimapT_std__string_Data_t,0))){
+    SWIG_fail_ptr("Event_getParam",1,SWIGTYPE_p_std__multimapT_std__string_Data_t);
+  }
+  
+  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_std__listT_Data_t,0))){
+    SWIG_fail_ptr("Event_getParam",3,SWIGTYPE_p_std__listT_Data_t);
+  }
+  
+  result = (bool)uscxml::Event::getParam((std::multimap< std::string,Data > const &)*arg1,(std::string const &)*arg2,*arg3);
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_Event_getParam__SWIG_3(lua_State* L) {
+  int SWIG_arg = 0;
+  uscxml::Event::params_t *arg1 = 0 ;
+  std::string *arg2 = 0 ;
+  bool *arg3 = 0 ;
+  std::string temp2 ;
+  bool result;
+  
+  SWIG_check_num_args("uscxml::Event::getParam",3,3)
+  if(!lua_isuserdata(L,1)) SWIG_fail_arg("uscxml::Event::getParam",1,"uscxml::Event::params_t const &");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("uscxml::Event::getParam",2,"std::string const &");
+  if(!lua_isuserdata(L,3)) SWIG_fail_arg("uscxml::Event::getParam",3,"bool &");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__multimapT_std__string_Data_t,0))){
+    SWIG_fail_ptr("Event_getParam",1,SWIGTYPE_p_std__multimapT_std__string_Data_t);
+  }
+  
+  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_bool,0))){
+    SWIG_fail_ptr("Event_getParam",3,SWIGTYPE_p_bool);
+  }
+  
+  result = (bool)uscxml::Event::getParam((std::multimap< std::string,Data > const &)*arg1,(std::string const &)*arg2,*arg3);
+  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_Event_getParam(lua_State* L) {
+  int argc;
+  int argv[4]={
+    1,2,3,4
+  };
+  
+  argc = lua_gettop(L);
+  if (argc == 3) {
+    int _v;
+    {
+      void *ptr;
+      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__multimapT_std__string_Data_t, 0)) {
+        _v = 0;
+      } else {
+        _v = 1;
+      }
+    }
+    if (_v) {
+      {
+        _v = lua_isstring(L,argv[1]);
+      }
+      if (_v) {
+        {
+          void *ptr;
+          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Data, 0)) {
+            _v = 0;
+          } else {
+            _v = 1;
+          }
+        }
+        if (_v) {
+          return _wrap_Event_getParam__SWIG_0(L);
+        }
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      void *ptr;
+      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__multimapT_std__string_Data_t, 0)) {
+        _v = 0;
+      } else {
+        _v = 1;
+      }
+    }
+    if (_v) {
+      {
+        _v = lua_isstring(L,argv[1]);
+      }
+      if (_v) {
+        {
+          void *ptr;
+          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_std__listT_Data_t, 0)) {
+            _v = 0;
+          } else {
+            _v = 1;
+          }
+        }
+        if (_v) {
+          return _wrap_Event_getParam__SWIG_1(L);
+        }
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      void *ptr;
+      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__multimapT_std__string_Data_t, 0)) {
+        _v = 0;
+      } else {
+        _v = 1;
+      }
+    }
+    if (_v) {
+      {
+        _v = lua_isstring(L,argv[1]);
+      }
+      if (_v) {
+        {
+          void *ptr;
+          if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_bool, 0)) {
+            _v = 0;
+          } else {
+            _v = 1;
+          }
+        }
+        if (_v) {
+          return _wrap_Event_getParam__SWIG_3(L);
+        }
+      }
+    }
+  }
+  
+  SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Event_getParam'\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    uscxml::Event::getParam(uscxml::Event::params_t const &,std::string const &,Data &)\n"
+    "    uscxml::Event::getParam(uscxml::Event::params_t const &,std::string const &,std::list< Data > &)\n"
+    "    uscxml::Event::getParam(uscxml::Event::params_t const &,std::string const &,bool &)\n");
+  lua_error(L);return 0;
+}
+
+
+static int _wrap_Event_raw_set(lua_State* L) {
+  int SWIG_arg = 0;
+  uscxml::Event *arg1 = (uscxml::Event *) 0 ;
+  std::string *arg2 = 0 ;
+  std::string temp2 ;
+  
+  SWIG_check_num_args("uscxml::Event::raw",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("uscxml::Event::raw",1,"uscxml::Event *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("uscxml::Event::raw",2,"std::string const &");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_uscxml__Event,0))){
+    SWIG_fail_ptr("Event_raw_set",1,SWIGTYPE_p_uscxml__Event);
+  }
+  
+  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
+  if (arg1) (arg1)->raw = *arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_Event_raw_get(lua_State* L) {
+  int SWIG_arg = 0;
+  uscxml::Event *arg1 = (uscxml::Event *) 0 ;
+  std::string *result = 0 ;
+  
+  SWIG_check_num_args("uscxml::Event::raw",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("uscxml::Event::raw",1,"uscxml::Event *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_uscxml__Event,0))){
+    SWIG_fail_ptr("Event_raw_get",1,SWIGTYPE_p_uscxml__Event);
+  }
+  
+  result = (std::string *) & ((arg1)->raw);
+  lua_pushlstring(L,result->data(),result->size()); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_Event_name_set(lua_State* L) {
+  int SWIG_arg = 0;
+  uscxml::Event *arg1 = (uscxml::Event *) 0 ;
+  std::string *arg2 = 0 ;
+  std::string temp2 ;
+  
+  SWIG_check_num_args("uscxml::Event::name",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("uscxml::Event::name",1,"uscxml::Event *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("uscxml::Event::name",2,"std::string const &");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_uscxml__Event,0))){
+    SWIG_fail_ptr("Event_name_set",1,SWIGTYPE_p_uscxml__Event);
+  }
+  
+  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
+  if (arg1) (arg1)->name = *arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_Event_name_get(lua_State* L) {
+  int SWIG_arg = 0;
+  uscxml::Event *arg1 = (uscxml::Event *) 0 ;
+  std::string *result = 0 ;
+  
+  SWIG_check_num_args("uscxml::Event::name",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("uscxml::Event::name",1,"uscxml::Event *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_uscxml__Event,0))){
+    SWIG_fail_ptr("Event_name_get",1,SWIGTYPE_p_uscxml__Event);
+  }
+  
+  result = (std::string *) & ((arg1)->name);
+  lua_pushlstring(L,result->data(),result->size()); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_Event_eventType_set(lua_State* L) {
+  int SWIG_arg = 0;
+  uscxml::Event *arg1 = (uscxml::Event *) 0 ;
+  uscxml::Event::Type arg2 ;
+  
+  SWIG_check_num_args("uscxml::Event::eventType",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("uscxml::Event::eventType",1,"uscxml::Event *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("uscxml::Event::eventType",2,"uscxml::Event::Type");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_uscxml__Event,0))){
+    SWIG_fail_ptr("Event_eventType_set",1,SWIGTYPE_p_uscxml__Event);
+  }
+  
+  arg2 = (uscxml::Event::Type)(int)lua_tonumber(L, 2);
+  if (arg1) (arg1)->eventType = arg2;
+  
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_Event_eventType_get(lua_State* L) {
+  int SWIG_arg = 0;
+  uscxml::Event *arg1 = (uscxml::Event *) 0 ;
+  uscxml::Event::Type result;
+  
+  SWIG_check_num_args("uscxml::Event::eventType",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("uscxml::Event::eventType",1,"uscxml::Event *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_uscxml__Event,0))){
+    SWIG_fail_ptr("Event_eventType_get",1,SWIGTYPE_p_uscxml__Event);
+  }
+  
+  result = (uscxml::Event::Type) ((arg1)->eventType);
+  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static void swig_delete_Event(void *obj) {
+uscxml::Event *arg1 = (uscxml::Event *) obj;
+delete arg1;
+}
+static int _proxy__wrap_new_Event(lua_State *L) {
+    assert(lua_istable(L,1));
+    lua_pushcfunction(L,_wrap_new_Event);
+    assert(!lua_isnil(L,-1));
+    lua_replace(L,1); /* replace our table with real constructor */
+    lua_call(L,lua_gettop(L)-1,1);
+    return 1;
+}
+static swig_lua_attribute swig_Event_attributes[] = {
+    { "raw", _wrap_Event_raw_get, _wrap_Event_raw_set },
+    { "name", _wrap_Event_name_get, _wrap_Event_name_set },
+    { "eventType", _wrap_Event_eventType_get, _wrap_Event_eventType_set },
+    {0,0,0}
+};
+static swig_lua_method swig_Event_methods[]= {
+    { "__lt", _wrap_Event___lt},
+    { "__eq", _wrap_Event___eq},
+    {0,0}
+};
+static swig_lua_method swig_Event_meta[] = {
+    { "__lt", _wrap_Event___lt},
+    { "__eq", _wrap_Event___eq},
+    {0,0}
+};
+
+static swig_lua_attribute swig_Event_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_Event_Sf_SwigStatic_constants[]= {
+    {SWIG_LUA_CONSTTAB_INT("INTERNAL", uscxml::Event::INTERNAL)},
+    {SWIG_LUA_CONSTTAB_INT("EXTERNAL", uscxml::Event::EXTERNAL)},
+    {SWIG_LUA_CONSTTAB_INT("PLATFORM", uscxml::Event::PLATFORM)},
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_Event_Sf_SwigStatic_methods[]= {
+    { "getParam", _wrap_Event_getParam},
+    {0,0}
+};
+static swig_lua_class* swig_Event_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_Event_Sf_SwigStatic = {
+    "Event",
+    swig_Event_Sf_SwigStatic_methods,
+    swig_Event_Sf_SwigStatic_attributes,
+    swig_Event_Sf_SwigStatic_constants,
+    swig_Event_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_Event_bases[] = {0};
+static const char *swig_Event_base_names[] = {0};
+static swig_lua_class _wrap_class_Event = { "Event", "Event", &SWIGTYPE_p_uscxml__Event,_proxy__wrap_new_Event, swig_delete_Event, swig_Event_methods, swig_Event_attributes, &swig_Event_Sf_SwigStatic, swig_Event_meta, swig_Event_bases, swig_Event_base_names };
+
+static int _wrap_new_ErrorEvent__SWIG_0(lua_State* L) {
+  int SWIG_arg = 0;
+  uscxml::ErrorEvent *result = 0 ;
+  
+  SWIG_check_num_args("uscxml::ErrorEvent::ErrorEvent",0,0)
+  result = (uscxml::ErrorEvent *)new uscxml::ErrorEvent();
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_uscxml__ErrorEvent,1); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_new_ErrorEvent__SWIG_1(lua_State* L) {
+  int SWIG_arg = 0;
+  std::string *arg1 = 0 ;
+  std::string temp1 ;
+  uscxml::ErrorEvent *result = 0 ;
+  
+  SWIG_check_num_args("uscxml::ErrorEvent::ErrorEvent",1,1)
+  if(!lua_isstring(L,1)) SWIG_fail_arg("uscxml::ErrorEvent::ErrorEvent",1,"std::string const &");
+  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
+  result = (uscxml::ErrorEvent *)new uscxml::ErrorEvent((std::string const &)*arg1);
+  SWIG_NewPointerObj(L,result,SWIGTYPE_p_uscxml__ErrorEvent,1); SWIG_arg++; 
+  return SWIG_arg;
+  
+  if(0) SWIG_fail;
+  
+fail:
+  lua_error(L);
+  return SWIG_arg;
+}
+
+
+static int _wrap_new_ErrorEvent(lua_State* L) {
+  int argc;
+  int argv[2]={
+    1,2
+  };
+  
+  argc = lua_gettop(L);
+  if (argc == 0) {
+    return _wrap_new_ErrorEvent__SWIG_0(L);
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      _v = lua_isstring(L,argv[0]);
+    }
+    if (_v) {
+      return _wrap_new_ErrorEvent__SWIG_1(L);
+    }
+  }
+  
+  SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_ErrorEvent'\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    uscxml::ErrorEvent::ErrorEvent()\n"
+    "    uscxml::ErrorEvent::ErrorEvent(std::string const &)\n");
+  lua_error(L);return 0;
+}
+
+
+static void swig_delete_ErrorEvent(void *obj) {
+uscxml::ErrorEvent *arg1 = (uscxml::ErrorEvent *) obj;
+delete arg1;
+}
+static int _proxy__wrap_new_ErrorEvent(lua_State *L) {
+    assert(lua_istable(L,1));
+    lua_pushcfunction(L,_wrap_new_ErrorEvent);
+    assert(!lua_isnil(L,-1));
+    lua_replace(L,1); /* replace our table with real constructor */
+    lua_call(L,lua_gettop(L)-1,1);
+    return 1;
+}
+static swig_lua_attribute swig_ErrorEvent_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_method swig_ErrorEvent_methods[]= {
+    {0,0}
+};
+static swig_lua_method swig_ErrorEvent_meta[] = {
+    {0,0}
+};
+
+static swig_lua_attribute swig_ErrorEvent_Sf_SwigStatic_attributes[] = {
+    {0,0,0}
+};
+static swig_lua_const_info swig_ErrorEvent_Sf_SwigStatic_constants[]= {
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_ErrorEvent_Sf_SwigStatic_methods[]= {
+    {0,0}
+};
+static swig_lua_class* swig_ErrorEvent_Sf_SwigStatic_classes[]= {
+    0
+};
+
+static swig_lua_namespace swig_ErrorEvent_Sf_SwigStatic = {
+    "ErrorEvent",
+    swig_ErrorEvent_Sf_SwigStatic_methods,
+    swig_ErrorEvent_Sf_SwigStatic_attributes,
+    swig_ErrorEvent_Sf_SwigStatic_constants,
+    swig_ErrorEvent_Sf_SwigStatic_classes,
+    0
+};
+static swig_lua_class *swig_ErrorEvent_bases[] = {0,0};
+static const char *swig_ErrorEvent_base_names[] = {"uscxml::Event *",0};
+static swig_lua_class _wrap_class_ErrorEvent = { "ErrorEvent", "ErrorEvent", &SWIGTYPE_p_uscxml__ErrorEvent,_proxy__wrap_new_ErrorEvent, swig_delete_ErrorEvent, swig_ErrorEvent_methods, swig_ErrorEvent_attributes, &swig_ErrorEvent_Sf_SwigStatic, swig_ErrorEvent_meta, swig_ErrorEvent_bases, swig_ErrorEvent_base_names };
+
+static swig_lua_attribute swig_SwigModule_attributes[] = {
+    { "DEBUG_UTF8_OUT", _wrap_DEBUG_UTF8_OUT_get, _wrap_DEBUG_UTF8_OUT_set },
+    { "DEBUG_UTF8_IN", _wrap_DEBUG_UTF8_IN_get, _wrap_DEBUG_UTF8_IN_set },
+    {0,0,0}
+};
+static swig_lua_const_info swig_SwigModule_constants[]= {
+    {SWIG_LUA_CONSTTAB_INT("XERCES_HAS_CPP_NAMESPACE", 1)},
+    {SWIG_LUA_CONSTTAB_INT("DOMException_INDEX_SIZE_ERR", XERCES_CPP_NAMESPACE::DOMException::INDEX_SIZE_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMException_DOMSTRING_SIZE_ERR", XERCES_CPP_NAMESPACE::DOMException::DOMSTRING_SIZE_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMException_HIERARCHY_REQUEST_ERR", XERCES_CPP_NAMESPACE::DOMException::HIERARCHY_REQUEST_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMException_WRONG_DOCUMENT_ERR", XERCES_CPP_NAMESPACE::DOMException::WRONG_DOCUMENT_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMException_INVALID_CHARACTER_ERR", XERCES_CPP_NAMESPACE::DOMException::INVALID_CHARACTER_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMException_NO_DATA_ALLOWED_ERR", XERCES_CPP_NAMESPACE::DOMException::NO_DATA_ALLOWED_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMException_NO_MODIFICATION_ALLOWED_ERR", XERCES_CPP_NAMESPACE::DOMException::NO_MODIFICATION_ALLOWED_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMException_NOT_FOUND_ERR", XERCES_CPP_NAMESPACE::DOMException::NOT_FOUND_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMException_NOT_SUPPORTED_ERR", XERCES_CPP_NAMESPACE::DOMException::NOT_SUPPORTED_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMException_INUSE_ATTRIBUTE_ERR", XERCES_CPP_NAMESPACE::DOMException::INUSE_ATTRIBUTE_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMException_INVALID_STATE_ERR", XERCES_CPP_NAMESPACE::DOMException::INVALID_STATE_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMException_SYNTAX_ERR", XERCES_CPP_NAMESPACE::DOMException::SYNTAX_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMException_INVALID_MODIFICATION_ERR", XERCES_CPP_NAMESPACE::DOMException::INVALID_MODIFICATION_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMException_NAMESPACE_ERR", XERCES_CPP_NAMESPACE::DOMException::NAMESPACE_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMException_INVALID_ACCESS_ERR", XERCES_CPP_NAMESPACE::DOMException::INVALID_ACCESS_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMException_VALIDATION_ERR", XERCES_CPP_NAMESPACE::DOMException::VALIDATION_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMException_TYPE_MISMATCH_ERR", XERCES_CPP_NAMESPACE::DOMException::TYPE_MISMATCH_ERR)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_ELEMENT_NODE", XERCES_CPP_NAMESPACE::DOMNode::ELEMENT_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_ATTRIBUTE_NODE", XERCES_CPP_NAMESPACE::DOMNode::ATTRIBUTE_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_TEXT_NODE", XERCES_CPP_NAMESPACE::DOMNode::TEXT_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_CDATA_SECTION_NODE", XERCES_CPP_NAMESPACE::DOMNode::CDATA_SECTION_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_ENTITY_REFERENCE_NODE", XERCES_CPP_NAMESPACE::DOMNode::ENTITY_REFERENCE_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_ENTITY_NODE", XERCES_CPP_NAMESPACE::DOMNode::ENTITY_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_PROCESSING_INSTRUCTION_NODE", XERCES_CPP_NAMESPACE::DOMNode::PROCESSING_INSTRUCTION_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_COMMENT_NODE", XERCES_CPP_NAMESPACE::DOMNode::COMMENT_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_DOCUMENT_NODE", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_DOCUMENT_TYPE_NODE", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_TYPE_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_DOCUMENT_FRAGMENT_NODE", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_FRAGMENT_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_NOTATION_NODE", XERCES_CPP_NAMESPACE::DOMNode::NOTATION_NODE)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_DOCUMENT_POSITION_DISCONNECTED", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_DISCONNECTED)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_DOCUMENT_POSITION_PRECEDING", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_PRECEDING)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_DOCUMENT_POSITION_FOLLOWING", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_FOLLOWING)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_DOCUMENT_POSITION_CONTAINS", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_CONTAINS)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_DOCUMENT_POSITION_CONTAINED_BY", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_CONTAINED_BY)},
+    {SWIG_LUA_CONSTTAB_INT("DOMNode_DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC", XERCES_CPP_NAMESPACE::DOMNode::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC)},
+    {SWIG_LUA_CONSTTAB_INT("Event_INTERNAL", uscxml::Event::INTERNAL)},
+    {SWIG_LUA_CONSTTAB_INT("Event_EXTERNAL", uscxml::Event::EXTERNAL)},
+    {SWIG_LUA_CONSTTAB_INT("Event_PLATFORM", uscxml::Event::PLATFORM)},
+    {0,0,0,0,0,0}
+};
+static swig_lua_method swig_SwigModule_methods[]= {
+    { "Event_getParam", _wrap_Event_getParam},
+    {0,0}
+};
+static swig_lua_class* swig_SwigModule_classes[]= {
+&_wrap_class_string,
+&_wrap_class_DOMException,
+&_wrap_class_DOMNode,
+&_wrap_class_DOMAttr,
+&_wrap_class_DOMElement,
+&_wrap_class_DOMEntity,
+&_wrap_class_DOMDocumentType,
+&_wrap_class_DOMCharacterData,
+&_wrap_class_DOMComment,
+&_wrap_class_DOMText,
+&_wrap_class_DOMCDATASection,
+&_wrap_class_DOMNodeList,
+&_wrap_class_DOMNamedNodeMap,
+&_wrap_class_DOMDocumentFragment,
+&_wrap_class_DOMEntityReference,
+&_wrap_class_DOMNotation,
+&_wrap_class_DOMProcessingInstruction,
+&_wrap_class_Event,
+&_wrap_class_ErrorEvent,
+    0
+};
+static swig_lua_namespace* swig_SwigModule_namespaces[] = {
+    0
+};
+
+static swig_lua_namespace swig_SwigModule = {
+    "LuaDOM",
+    swig_SwigModule_methods,
+    swig_SwigModule_attributes,
+    swig_SwigModule_constants,
+    swig_SwigModule_classes,
+    swig_SwigModule_namespaces
+};
+#ifdef __cplusplus
+}
+#endif
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMText(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((XERCES_CPP_NAMESPACE::DOMText *)  ((XERCES_CPP_NAMESPACE::DOMCDATASection *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMTextTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((XERCES_CPP_NAMESPACE::DOMCharacterData *)  ((XERCES_CPP_NAMESPACE::DOMText *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMCommentTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((XERCES_CPP_NAMESPACE::DOMCharacterData *)  ((XERCES_CPP_NAMESPACE::DOMComment *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((XERCES_CPP_NAMESPACE::DOMCharacterData *) (XERCES_CPP_NAMESPACE::DOMText *) ((XERCES_CPP_NAMESPACE::DOMCDATASection *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMElementTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((XERCES_CPP_NAMESPACE::DOMNode *)  ((XERCES_CPP_NAMESPACE::DOMElement *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMDocumentFragmentTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((XERCES_CPP_NAMESPACE::DOMNode *)  ((XERCES_CPP_NAMESPACE::DOMDocumentFragment *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMAttrTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((XERCES_CPP_NAMESPACE::DOMNode *)  ((XERCES_CPP_NAMESPACE::DOMAttr *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMDocumentTypeTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((XERCES_CPP_NAMESPACE::DOMNode *)  ((XERCES_CPP_NAMESPACE::DOMDocumentType *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMCharacterDataTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((XERCES_CPP_NAMESPACE::DOMNode *)  ((XERCES_CPP_NAMESPACE::DOMCharacterData *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMTextTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) (XERCES_CPP_NAMESPACE::DOMCharacterData *) ((XERCES_CPP_NAMESPACE::DOMText *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMCommentTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) (XERCES_CPP_NAMESPACE::DOMCharacterData *) ((XERCES_CPP_NAMESPACE::DOMComment *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMProcessingInstructionTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((XERCES_CPP_NAMESPACE::DOMNode *)  ((XERCES_CPP_NAMESPACE::DOMProcessingInstruction *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMEntityTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((XERCES_CPP_NAMESPACE::DOMNode *)  ((XERCES_CPP_NAMESPACE::DOMEntity *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMEntityReferenceTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((XERCES_CPP_NAMESPACE::DOMNode *)  ((XERCES_CPP_NAMESPACE::DOMEntityReference *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((XERCES_CPP_NAMESPACE::DOMNode *) (XERCES_CPP_NAMESPACE::DOMCharacterData *)(XERCES_CPP_NAMESPACE::DOMText *) ((XERCES_CPP_NAMESPACE::DOMCDATASection *) x));
+}
+static void *_p_XERCES_CPP_NAMESPACE__DOMNotationTo_p_XERCES_CPP_NAMESPACE__DOMNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((XERCES_CPP_NAMESPACE::DOMNode *)  ((XERCES_CPP_NAMESPACE::DOMNotation *) x));
+}
+static void *_p_uscxml__ErrorEventTo_p_uscxml__Event(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((uscxml::Event *)  ((uscxml::ErrorEvent *) x));
+}
+static swig_type_info _swigt__p_Data = {"_p_Data", "Data *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMAttr = {"_p_XERCES_CPP_NAMESPACE__DOMAttr", "XERCES_CPP_NAMESPACE::DOMAttr *", 0, 0, (void*)&_wrap_class_DOMAttr, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection = {"_p_XERCES_CPP_NAMESPACE__DOMCDATASection", "XERCES_CPP_NAMESPACE::DOMCDATASection *", 0, 0, (void*)&_wrap_class_DOMCDATASection, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMCharacterData = {"_p_XERCES_CPP_NAMESPACE__DOMCharacterData", "XERCES_CPP_NAMESPACE::DOMCharacterData *", 0, 0, (void*)&_wrap_class_DOMCharacterData, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMComment = {"_p_XERCES_CPP_NAMESPACE__DOMComment", "XERCES_CPP_NAMESPACE::DOMComment *", 0, 0, (void*)&_wrap_class_DOMComment, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMDocument = {"_p_XERCES_CPP_NAMESPACE__DOMDocument", "XERCES_CPP_NAMESPACE::DOMDocument *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment = {"_p_XERCES_CPP_NAMESPACE__DOMDocumentFragment", "XERCES_CPP_NAMESPACE::DOMDocumentFragment *", 0, 0, (void*)&_wrap_class_DOMDocumentFragment, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentType = {"_p_XERCES_CPP_NAMESPACE__DOMDocumentType", "XERCES_CPP_NAMESPACE::DOMDocumentType *", 0, 0, (void*)&_wrap_class_DOMDocumentType, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMElement = {"_p_XERCES_CPP_NAMESPACE__DOMElement", "XERCES_CPP_NAMESPACE::DOMElement *", 0, 0, (void*)&_wrap_class_DOMElement, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMEntity = {"_p_XERCES_CPP_NAMESPACE__DOMEntity", "XERCES_CPP_NAMESPACE::DOMEntity *", 0, 0, (void*)&_wrap_class_DOMEntity, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMEntityReference = {"_p_XERCES_CPP_NAMESPACE__DOMEntityReference", "XERCES_CPP_NAMESPACE::DOMEntityReference *", 0, 0, (void*)&_wrap_class_DOMEntityReference, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMException = {"_p_XERCES_CPP_NAMESPACE__DOMException", "XERCES_CPP_NAMESPACE::DOMException *", 0, 0, (void*)&_wrap_class_DOMException, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap = {"_p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap", "XERCES_CPP_NAMESPACE::DOMNamedNodeMap *", 0, 0, (void*)&_wrap_class_DOMNamedNodeMap, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMNode = {"_p_XERCES_CPP_NAMESPACE__DOMNode", "XERCES_CPP_NAMESPACE::DOMNode *", 0, 0, (void*)&_wrap_class_DOMNode, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMNodeList = {"_p_XERCES_CPP_NAMESPACE__DOMNodeList", "XERCES_CPP_NAMESPACE::DOMNodeList *", 0, 0, (void*)&_wrap_class_DOMNodeList, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMNotation = {"_p_XERCES_CPP_NAMESPACE__DOMNotation", "XERCES_CPP_NAMESPACE::DOMNotation *", 0, 0, (void*)&_wrap_class_DOMNotation, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction = {"_p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction", "XERCES_CPP_NAMESPACE::DOMProcessingInstruction *", 0, 0, (void*)&_wrap_class_DOMProcessingInstruction, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMText = {"_p_XERCES_CPP_NAMESPACE__DOMText", "XERCES_CPP_NAMESPACE::DOMText *", 0, 0, (void*)&_wrap_class_DOMText, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMTypeInfo = {"_p_XERCES_CPP_NAMESPACE__DOMTypeInfo", "XERCES_CPP_NAMESPACE::DOMTypeInfo *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__DOMUserDataHandler = {"_p_XERCES_CPP_NAMESPACE__DOMUserDataHandler", "XERCES_CPP_NAMESPACE::DOMUserDataHandler *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_XERCES_CPP_NAMESPACE__MemoryManager = {"_p_XERCES_CPP_NAMESPACE__MemoryManager", "XERCES_CPP_NAMESPACE::MemoryManager *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int16_t = {"_p_int16_t", "XMLInt16 *|int16_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int32_t = {"_p_int32_t", "int32_t *|XMLInt32 *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int64_t = {"_p_int64_t", "int64_t *|XMLInt64 *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_namelist_t = {"_p_namelist_t", "namelist_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_params_t = {"_p_params_t", "params_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *|XMLSize_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ssize_t = {"_p_ssize_t", "ssize_t *|XMLSSize_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__listT_Data_t = {"_p_std__listT_Data_t", "std::list< Data > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__multimapT_std__string_Data_t = {"_p_std__multimapT_std__string_Data_t", "uscxml::Event::params_t *|std::multimap< std::string,Data > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)&_wrap_class_string, 0};
+static swig_type_info _swigt__p_uint16_t = {"_p_uint16_t", "XMLUInt16 *|UTF16Ch *|XMLCh *|uint16_t *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_uint32_t = {"_p_uint32_t", "uint32_t *|XMLUInt32 *|UCS4Ch *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_uint64_t = {"_p_uint64_t", "uint64_t *|XMLUInt64 *|XMLFilePos *|XMLFileLoc *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|XMLByte *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_uscxml__ErrorEvent = {"_p_uscxml__ErrorEvent", "uscxml::ErrorEvent *", 0, 0, (void*)&_wrap_class_ErrorEvent, 0};
+static swig_type_info _swigt__p_uscxml__Event = {"_p_uscxml__Event", "uscxml::Event *", 0, 0, (void*)&_wrap_class_Event, 0};
+static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_Data,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMAttr,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMCharacterData,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMComment,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMDocument,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentType,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMElement,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMEntity,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMEntityReference,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMException,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMNode,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMNodeList,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMNotation,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMText,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMTypeInfo,
+  &_swigt__p_XERCES_CPP_NAMESPACE__DOMUserDataHandler,
+  &_swigt__p_XERCES_CPP_NAMESPACE__MemoryManager,
+  &_swigt__p_bool,
+  &_swigt__p_int16_t,
+  &_swigt__p_int32_t,
+  &_swigt__p_int64_t,
+  &_swigt__p_namelist_t,
+  &_swigt__p_params_t,
+  &_swigt__p_size_t,
+  &_swigt__p_ssize_t,
+  &_swigt__p_std__listT_Data_t,
+  &_swigt__p_std__multimapT_std__string_Data_t,
+  &_swigt__p_std__string,
+  &_swigt__p_uint16_t,
+  &_swigt__p_uint32_t,
+  &_swigt__p_uint64_t,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_uscxml__ErrorEvent,
+  &_swigt__p_uscxml__Event,
+  &_swigt__p_void,
+};
+
+static swig_cast_info _swigc__p_Data[] = {  {&_swigt__p_Data, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMAttr[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMAttr, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMCDATASection[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMCharacterData[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0, 0, 0},  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMText, _p_XERCES_CPP_NAMESPACE__DOMTextTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0, 0},  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMComment, _p_XERCES_CPP_NAMESPACE__DOMCommentTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0, 0},  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection, _p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMCharacterData, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMComment[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMComment, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMDocument[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentType[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentType, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMElement[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMElement, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMEntity[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMEntity, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMEntityReference[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMEntityReference, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMException[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMException, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMNode[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMElement, _p_XERCES_CPP_NAMESPACE__DOMElementTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0},  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment, _p_XERCES_CPP_NAMESPACE__DOMDocumentFragmentTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0},  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMAttr, _p_XERCES_CPP_NAMESPACE__DOMAttrTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0},  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMDocumentType, _p_XERCES_CPP_NAMESPACE__DOMDocumentTypeTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0},  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCharacterData, _p_XERCES_CPP_NAMESPACE__DOMCharacterDataTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0},  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMText, _p_XERCES_CPP_NAMESPACE__DOMTextTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0},  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMComment, _p_XERCES_CPP_NAMESPACE__DOMCommentTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0},  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, _p_XERCES_CPP_NAMESPACE__DOMProcessingInstructionTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0},  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMEntity, _p_XERCES_CPP_NAMESPACE__DOMEntityTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0},  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMEntityReference, _p_XERCES_CPP_NAMESPACE__DOMEntityReferenceTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0},  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0, 0},  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection, _p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0},  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNotation, _p_XERCES_CPP_NAMESPACE__DOMNotationTo_p_XERCES_CPP_NAMESPACE__DOMNode, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMNodeList[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNodeList, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMNotation[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMNotation, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMText[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMText, 0, 0, 0},  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMCDATASection, _p_XERCES_CPP_NAMESPACE__DOMCDATASectionTo_p_XERCES_CPP_NAMESPACE__DOMText, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMTypeInfo[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__DOMUserDataHandler[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__DOMUserDataHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_XERCES_CPP_NAMESPACE__MemoryManager[] = {  {&_swigt__p_XERCES_CPP_NAMESPACE__MemoryManager, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_bool[] = {  {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int16_t[] = {  {&_swigt__p_int16_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int32_t[] = {  {&_swigt__p_int32_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int64_t[] = {  {&_swigt__p_int64_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_namelist_t[] = {  {&_swigt__p_namelist_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_params_t[] = {  {&_swigt__p_params_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_size_t[] = {  {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ssize_t[] = {  {&_swigt__p_ssize_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__listT_Data_t[] = {  {&_swigt__p_std__listT_Data_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__multimapT_std__string_Data_t[] = {  {&_swigt__p_std__multimapT_std__string_Data_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_uint16_t[] = {  {&_swigt__p_uint16_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_uint32_t[] = {  {&_swigt__p_uint32_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_uint64_t[] = {  {&_swigt__p_uint64_t, 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_uscxml__ErrorEvent[] = {  {&_swigt__p_uscxml__ErrorEvent, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_uscxml__Event[] = {  {&_swigt__p_uscxml__Event, 0, 0, 0},  {&_swigt__p_uscxml__ErrorEvent, _p_uscxml__ErrorEventTo_p_uscxml__Event, 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 *swig_cast_initial[] = {
+  _swigc__p_Data,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMAttr,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMCDATASection,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMCharacterData,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMComment,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMDocument,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentFragment,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMDocumentType,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMElement,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMEntity,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMEntityReference,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMException,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMNamedNodeMap,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMNode,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMNodeList,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMNotation,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMProcessingInstruction,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMText,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMTypeInfo,
+  _swigc__p_XERCES_CPP_NAMESPACE__DOMUserDataHandler,
+  _swigc__p_XERCES_CPP_NAMESPACE__MemoryManager,
+  _swigc__p_bool,
+  _swigc__p_int16_t,
+  _swigc__p_int32_t,
+  _swigc__p_int64_t,
+  _swigc__p_namelist_t,
+  _swigc__p_params_t,
+  _swigc__p_size_t,
+  _swigc__p_ssize_t,
+  _swigc__p_std__listT_Data_t,
+  _swigc__p_std__multimapT_std__string_Data_t,
+  _swigc__p_std__string,
+  _swigc__p_uint16_t,
+  _swigc__p_uint32_t,
+  _swigc__p_uint64_t,
+  _swigc__p_unsigned_char,
+  _swigc__p_uscxml__ErrorEvent,
+  _swigc__p_uscxml__Event,
+  _swigc__p_void,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * 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
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *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 %d\n", 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 %d %s\n", 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 %d %s\n", 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
+
+
+
+/* Forward declaration of where the user's %init{} gets inserted */
+void SWIG_init_user(lua_State* L );
+    
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* this is the initialization function
+  added at the very end of the code
+  the function is always called SWIG_init, but an earlier #define will rename it
+*/
+#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
+LUALIB_API int SWIG_init(lua_State* L)
+#else
+SWIGEXPORT int SWIG_init(lua_State* L) /* default Lua action */
+#endif
+{
+#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) /* valid for both Lua and eLua */
+  int i;
+  int globalRegister = 0;
+  /* start with global table */
+  lua_pushglobaltable (L);
+  /* SWIG's internal initialisation */
+  SWIG_InitializeModule((void*)L);
+  SWIG_PropagateClientData();
+#endif
+
+#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) || defined(SWIG_LUA_ELUA_EMULATE)
+  /* add a global fn */
+  SWIG_Lua_add_function(L,"swig_type",SWIG_Lua_type);
+  SWIG_Lua_add_function(L,"swig_equals",SWIG_Lua_class_equal);
+#endif
+
+#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
+  /* set up base class pointers (the hierarchy) */
+  for (i = 0; swig_types[i]; i++){
+    if (swig_types[i]->clientdata){
+      SWIG_Lua_init_base_class(L,(swig_lua_class*)(swig_types[i]->clientdata));
+    }
+  }
+#ifdef SWIG_LUA_MODULE_GLOBAL
+  globalRegister = 1;
+#endif
+
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
+  SWIG_Lua_namespace_register(L,&swig_SwigModule, globalRegister);
+#endif
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
+  for (i = 0; swig_types[i]; i++){
+    if (swig_types[i]->clientdata){
+      SWIG_Lua_elua_class_register_instance(L,(swig_lua_class*)(swig_types[i]->clientdata));
+    }
+  }
+#endif
+
+#if defined(SWIG_LUA_ELUA_EMULATE)
+  lua_newtable(L);
+  SWIG_Lua_elua_emulate_register(L,swig_SwigModule.ns_methods);
+  SWIG_Lua_elua_emulate_register_clear(L);
+  if(globalRegister) {
+    lua_pushstring(L,swig_SwigModule.name);
+    lua_pushvalue(L,-2);
+    lua_rawset(L,-4);
+  }
+#endif
+
+#endif
+
+#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
+  /* invoke user-specific initialization */
+  SWIG_init_user(L);
+  /* end module */
+  /* Note: We do not clean up the stack here (Lua will do this for us). At this
+     point, we have the globals table and out module table on the stack. Returning
+     one value makes the module table the result of the require command. */
+  return 1;
+#else
+  return 0;
+#endif
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+
+const char* SWIG_LUACODE=
+  "";
+
+void SWIG_init_user(lua_State* L)
+{
+  SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode->dcast = (swig_dycast_func) DOMNode_dynamic_cast;
+  
+  /* exec Lua code if applicable */
+  SWIG_Lua_dostring(L,SWIG_LUACODE);
+}
+
diff --git a/src/uscxml/plugins/datamodel/lua/LuaDataModel.cpp b/src/uscxml/plugins/datamodel/lua/LuaDataModel.cpp
index f6cb570..6fc5ac4 100644
--- a/src/uscxml/plugins/datamodel/lua/LuaDataModel.cpp
+++ b/src/uscxml/plugins/datamodel/lua/LuaDataModel.cpp
@@ -17,10 +17,10 @@
  *  @endcond
  */
 
-#include <boost/algorithm/string.hpp>
-
 #include "uscxml/Common.h"
+#include "uscxml/util/URL.h"
 #include "uscxml/util/String.h"
+
 #include "LuaDataModel.h"
 
 // disable forcing to bool performance warning
@@ -29,31 +29,71 @@
 #include "LuaBridge.h"
 #pragma warning(pop)
 
-#include "uscxml/dom/DOMUtils.h"
-
-#include "uscxml/Message.h"
-#include <glog/logging.h>
+#include "uscxml/messages/Event.h"
+#include "uscxml/util/DOM.h"
+#include <easylogging++.h>
+#include <boost/algorithm/string.hpp>
 
-#ifdef BUILD_AS_PLUGINS
-#include <Pluma/Connector.hpp>
-#endif
+//#include "LuaDOM.cpp.inc"
 
 namespace uscxml {
 
-#ifdef BUILD_AS_PLUGINS
-PLUMA_CONNECTOR
-bool pluginConnect(pluma::Host& host) {
-	host.add( new LuaDataModelProvider() );
-	return true;
-}
-#endif
-
-static int luaInspect(lua_State * l) {
-	return 0;
-}
+//static int luaInspect(lua_State * l) {
+//	return 0;
+//}
 
 bool _luaHasXMLParser = false;
 
+static int luaEval(lua_State* luaState, const std::string& expr) {
+	int preStack = lua_gettop(luaState);
+	int error = luaL_loadstring(luaState, expr.c_str()) || lua_pcall(luaState, 0, LUA_MULTRET, 0);
+	if (error) {
+		std::string errMsg = lua_tostring(luaState, -1);
+		lua_pop(luaState, 1);  /* pop error message from the stack */
+		ERROR_EXECUTION_THROW(errMsg);
+	}
+	int postStack = lua_gettop(luaState);
+	return postStack - preStack;
+}
+
+static Data getLuaAsData(lua_State* _luaState, const luabridge::LuaRef& lua) {
+	Data data;
+	if (lua.isFunction()) {
+		// TODO: this might lead to a stack-overflow
+		luabridge::LuaRef luaEvald = lua();
+		return getLuaAsData(_luaState, luaEvald);
+	} else if(lua.isLightUserdata() || lua.isUserdata()) {
+		// not sure what to do
+	} else if(lua.isThread()) {
+		// not sure what to do
+	} else if(lua.isNil()) {
+		data.atom = "nil";
+		data.type = Data::INTERPRETED;
+	} else if(lua.isNumber()) {
+		data.atom = toStr(lua.cast<int>());
+		data.type = Data::INTERPRETED;
+	} else if(lua.isString()) {
+		data.atom = lua.tostring();
+		data.type = Data::VERBATIM;
+	} else if(lua.isTable()) {
+		bool isArray = false;
+		bool isMap = false;
+		for (luabridge::Iterator iter (lua); !iter.isNil(); ++iter) {
+			luabridge::LuaRef luaKey = iter.key();
+			luabridge::LuaRef luaVal = *iter;
+			if (luaKey.isString()) {
+				assert(!isArray);
+				isMap = true;
+				data.compound[luaKey.tostring()] = getLuaAsData(_luaState, luaVal);
+			} else {
+				assert(!isMap);
+				isArray = true;
+				data.array.push_back(getLuaAsData(_luaState, luaVal));
+			}
+		}
+	}
+	return data;
+}
 
 static luabridge::LuaRef getDataAsLua(lua_State* _luaState, const Data& data) {
 	luabridge::LuaRef luaData (_luaState);
@@ -80,24 +120,24 @@ static luabridge::LuaRef getDataAsLua(lua_State* _luaState, const Data& data) {
 			luaData[compoundIter->first] = getDataAsLua(_luaState, compoundIter->second);
 			compoundIter++;
 		}
-		luaData["inspect"] = luaInspect;
+//		luaData["inspect"] = luaInspect;
 		return luaData;
 	}
 	if (data.array.size() > 0) {
 		luaData = luabridge::newTable(_luaState);
 		std::list<Data>::const_iterator arrayIter = data.array.begin();
-		uint32_t index = 0;
+//		uint32_t index = 0;
 		while(arrayIter != data.array.end()) {
-			luaData[index++] = getDataAsLua(_luaState, *arrayIter);
+//            luaData[index++] = getDataAsLua(_luaState, *arrayIter);
+			luaData.append(getDataAsLua(_luaState, *arrayIter));
 			arrayIter++;
 		}
-		luaData["inspect"] = luaInspect;
+//		luaData["inspect"] = luaInspect;
 		return luaData;
 	}
 	if (data.atom.size() > 0) {
 		switch (data.type) {
 		case Data::VERBATIM: {
-//				luaData = "\"" + data.atom + "\"";
 			luaData = data.atom;
 			break;
 		}
@@ -109,29 +149,34 @@ static luabridge::LuaRef getDataAsLua(lua_State* _luaState, const Data& data) {
 					luaData = strTo<long>(data.atom);
 				}
 			} else {
-				luaData = data.atom;
+				int retVals = luaEval(_luaState, "return(" + data.atom + ");");
+				if (retVals == 1) {
+					luaData = luabridge::LuaRef::fromStack(_luaState, -1);
+				}
+				lua_pop(_luaState, retVals);
 			}
 		}
 		}
 		return luaData;
 	}
-	return luaData;
+	// hopefully this is nil
+	return luabridge::LuaRef(_luaState);
 }
 
 LuaDataModel::LuaDataModel() {
 	_luaState = NULL;
 }
 
-static int luaInFunction(lua_State * l) {
-	luabridge::LuaRef ref = luabridge::getGlobal(l, "__interpreter");
-	InterpreterInfo* interpreter = ref.cast<InterpreterInfo*>();
+int LuaDataModel::luaInFunction(lua_State * l) {
+	luabridge::LuaRef ref = luabridge::getGlobal(l, "__datamodel");
+	LuaDataModel* dm = ref.cast<LuaDataModel*>();
 
 	int stackSize = lua_gettop(l);
 	for (size_t i = 0; i < stackSize; i++) {
 		if (!lua_isstring(l, -1 - i))
 			continue;
 		std::string stateName = lua_tostring(l, -1 - i);
-		if (interpreter->isInState(stateName))
+		if (dm->_callbacks->isInState(stateName))
 			continue;
 		lua_pushboolean(l, 0);
 		return 1;
@@ -140,9 +185,9 @@ static int luaInFunction(lua_State * l) {
 	return 1;
 }
 
-boost::shared_ptr<DataModelImpl> LuaDataModel::create(InterpreterInfo* interpreter) {
-	boost::shared_ptr<LuaDataModel> dm = boost::shared_ptr<LuaDataModel>(new LuaDataModel());
-	dm->_interpreter = interpreter;
+std::shared_ptr<DataModelImpl> LuaDataModel::create(DataModelCallbacks* callbacks) {
+	std::shared_ptr<LuaDataModel> dm(new LuaDataModel());
+	dm->_callbacks = callbacks;
 	dm->_luaState = luaL_newstate();
 	luaL_openlibs(dm->_luaState);
 
@@ -161,23 +206,33 @@ boost::shared_ptr<DataModelImpl> LuaDataModel::create(InterpreterInfo* interpret
 		LOG(INFO) << e.what();
 	}
 
-	luabridge::getGlobalNamespace(dm->_luaState).beginClass<InterpreterInfo>("Interpreter").endClass();
-	luabridge::setGlobal(dm->_luaState, dm->_interpreter, "__interpreter");
+	luabridge::getGlobalNamespace(dm->_luaState).beginClass<LuaDataModel>("DataModel").endClass();
+	luabridge::setGlobal(dm->_luaState, dm.get(), "__datamodel");
 
 	luabridge::getGlobalNamespace(dm->_luaState).addCFunction("In", luaInFunction);
 
 	luabridge::LuaRef ioProcTable = luabridge::newTable(dm->_luaState);
-
-	std::map<std::string, IOProcessor>::const_iterator ioProcIter = dm->_interpreter->getIOProcessors().begin();
-	while(ioProcIter != dm->_interpreter->getIOProcessors().end()) {
+	std::map<std::string, IOProcessor> ioProcs = dm->_callbacks->getIOProcessors();
+	std::map<std::string, IOProcessor>::const_iterator ioProcIter = ioProcs.begin();
+	while(ioProcIter != ioProcs.end()) {
 		Data ioProcData = ioProcIter->second.getDataModelVariables();
 		ioProcTable[ioProcIter->first] = getDataAsLua(dm->_luaState, ioProcData);
 		ioProcIter++;
 	}
 	luabridge::setGlobal(dm->_luaState, ioProcTable, "_ioprocessors");
 
-	luabridge::setGlobal(dm->_luaState, dm->_interpreter->getName(), "_name");
-	luabridge::setGlobal(dm->_luaState, dm->_interpreter->getSessionId(), "_sessionid");
+	luabridge::LuaRef invTable = luabridge::newTable(dm->_luaState);
+	std::map<std::string, Invoker> invokers = dm->_callbacks->getInvokers();
+	std::map<std::string, Invoker>::const_iterator invIter = invokers.begin();
+	while(invIter != invokers.end()) {
+		Data invData = invIter->second.getDataModelVariables();
+		invTable[invIter->first] = getDataAsLua(dm->_luaState, invData);
+		invIter++;
+	}
+	luabridge::setGlobal(dm->_luaState, invTable, "_invokers");
+
+	luabridge::setGlobal(dm->_luaState, dm->_callbacks->getName(), "_name");
+	luabridge::setGlobal(dm->_luaState, dm->_callbacks->getSessionId(), "_sessionid");
 
 	return dm;
 }
@@ -187,42 +242,8 @@ LuaDataModel::~LuaDataModel() {
 		lua_close(_luaState);
 }
 
-void LuaDataModel::pushContext() {
-}
-
-void LuaDataModel::popContext() {
-}
-
-void LuaDataModel::initialize() {
-}
-
-static Data getLuaAsData(const luabridge::LuaRef& lua) {
-	Data data;
-	if (lua.isFunction()) {
-		// TODO: this might lead to a stack-overflow
-		luabridge::LuaRef luaEvald = lua();
-		return getLuaAsData(luaEvald);
-	} else if(lua.isLightUserdata() || lua.isUserdata()) {
-		// not sure what to do
-	} else if(lua.isThread()) {
-		// not sure what to do
-	} else if(lua.isNil()) {
-		data.atom = "undefined";
-		data.type = Data::INTERPRETED;
-	} else if(lua.isString()) {
-		data.atom = lua.tostring();
-		data.type = Data::VERBATIM;
-	} else if(lua.isNumber()) {
-		data.atom = lua.tostring();
-		data.type = Data::INTERPRETED;
-	} else if(lua.isTable()) {
-		for (luabridge::Iterator iter (lua); !iter.isNil (); ++iter) {
-			luabridge::LuaRef luaKey = iter.key();
-			luabridge::LuaRef luaVal = *iter;
-			data.compound[luaKey.tostring()] = getLuaAsData(luaVal);
-		}
-	}
-	return data;
+void LuaDataModel::addExtension(DataModelExtension* ext) {
+	ERROR_EXECUTION_THROW("Extensions unimplemented in lua datamodel");
 }
 
 void LuaDataModel::setEvent(const Event& event) {
@@ -230,14 +251,17 @@ void LuaDataModel::setEvent(const Event& event) {
 	luaEvent = luabridge::newTable(_luaState);
 
 	luaEvent["name"] = event.name;
-	luaEvent["raw"] = event.raw;
-	luaEvent["xml"] = event.xml;
-	luaEvent["origin"] = event.origin;
-	luaEvent["origintype"] = event.origintype;
-	luaEvent["content"] = event.content;
-	luaEvent["invokeId"] = event.invokeid;
-	luaEvent["sendId"] = event.sendid;
-	luaEvent["inspect"] = luaInspect;
+	if (event.raw.size() > 0)
+		luaEvent["raw"] = event.raw;
+	if (event.origin.size() > 0)
+		luaEvent["origin"] = event.origin;
+	if (event.origintype.size() > 0)
+		luaEvent["origintype"] = event.origintype;
+	if (event.invokeid.size() > 0)
+		luaEvent["invokeid"] = event.invokeid;
+	if (!event.hideSendId)
+		luaEvent["sendid"] = event.sendid;
+//	luaEvent["inspect"] = luaInspect;
 
 	switch (event.eventType) {
 	case Event::INTERNAL:
@@ -254,64 +278,44 @@ void LuaDataModel::setEvent(const Event& event) {
 		break;
 	}
 
-	if (event.dom) {
+	if (event.data.node) {
 		if (_luaHasXMLParser) {
 			const luabridge::LuaRef& luaLom = luabridge::getGlobal(_luaState, "lxp.lom");
 			const luabridge::LuaRef& luaLomParse = luaLom["parse"];
 			assert(luaLomParse.isFunction());
 			std::stringstream luaXMLSS;
-			luaXMLSS << event.dom;
+			luaXMLSS << event.data.node;
 			try {
 				luaEvent["data"] = luaLomParse(luaXMLSS.str());
 			} catch (luabridge::LuaException e) {
 				ERROR_EXECUTION_THROW(e.what());
 			}
 		} else {
-			// some error events have a dom node attached - do not throw for them
-			// issue65
-			if (!nameMatch("error.*", event.name)) {
-				ERROR_EXECUTION_THROW("No DOM support in Lua datamodel");
-			}
-		}
-	} else if (event.content.length() > 0) {
-		// _event.data is a string or JSON
-		Data json = Data::fromJSON(event.content);
-		if (!json.empty()) {
-			luaEvent["data"] = getDataAsLua(_luaState, json);
-		} else {
-			// test179
-			std::string trimmed = boost::trim_copy(event.content);
-			if ((boost::starts_with(trimmed, "'") && boost::ends_with(trimmed, "'")) ||
-			        (boost::starts_with(trimmed, "\"") && boost::ends_with(trimmed, "\""))) {
-				luaEvent["data"] = spaceNormalize(event.content);
-			} else {
-				Data tmp(event.content, Data::INTERPRETED);
-				luaEvent["data"] = getDataAsLua(_luaState, tmp);
-			}
+			ERROR_EXECUTION_THROW("No DOM support in Lua datamodel");
 		}
 	} else {
 		// _event.data is KVP
-		Event eventCopy(event);
+		Data d = event.data;
 
-		if (!eventCopy.params.empty()) {
-			Event::params_t::iterator paramIter = eventCopy.params.begin();
-			while(paramIter != eventCopy.params.end()) {
-				eventCopy.data.compound[paramIter->first] = paramIter->second;
+		if (!event.params.empty()) {
+			Event::params_t::const_iterator paramIter = event.params.begin();
+			while(paramIter != event.params.end()) {
+				d.compound[paramIter->first] = paramIter->second;
 				paramIter++;
 			}
 		}
-		if (!eventCopy.namelist.empty()) {
-			Event::namelist_t::iterator nameListIter = eventCopy.namelist.begin();
-			while(nameListIter != eventCopy.namelist.end()) {
-				eventCopy.data.compound[nameListIter->first] = nameListIter->second;
+		if (!event.namelist.empty()) {
+			Event::namelist_t::const_iterator nameListIter = event.namelist.begin();
+			while(nameListIter != event.namelist.end()) {
+				d.compound[nameListIter->first] = nameListIter->second;
 				nameListIter++;
 			}
 		}
 
-		if (!eventCopy.data.empty()) {
-			luabridge::LuaRef luaData = getDataAsLua(_luaState, eventCopy.data);
+		if (!d.empty()) {
+			luabridge::LuaRef luaData = getDataAsLua(_luaState, d);
 			assert(luaEvent.isTable());
-			assert(luaData.isTable());
+			// assert(luaData.isTable()); // not necessarily test179
 			luaEvent["data"] = luaData;
 		}
 	}
@@ -319,31 +323,29 @@ void LuaDataModel::setEvent(const Event& event) {
 	luabridge::setGlobal(_luaState, luaEvent, "_event");
 }
 
-Data LuaDataModel::getStringAsData(const std::string& content) {
-//    Data data = Data::fromJSON(content);
+Data LuaDataModel::evalAsData(const std::string& content) {
 	Data data;
-	if (data.empty()) {
-		std::string trimmedExpr = boost::trim_copy(content);
-		if (!boost::starts_with(trimmedExpr, "return")) {
-			trimmedExpr = "return(" + trimmedExpr + ");";
-		}
 
-		int retVals = luaEval(Arabica::DOM::Element<std::string>(), trimmedExpr);
+	std::string trimmedExpr = boost::trim_copy(content);
+
+	try {
+		int retVals = luaEval(_luaState, "return(" + trimmedExpr + ")");
 		if (retVals == 1) {
-			data = getLuaAsData(luabridge::LuaRef::fromStack(_luaState, -1));
+			data = getLuaAsData(_luaState, luabridge::LuaRef::fromStack(_luaState, -1));
 		}
 		lua_pop(_luaState, retVals);
-
+	} catch (ErrorEvent e) {
+		int retVals = luaEval(_luaState, trimmedExpr);
+		if (retVals == 1) {
+			data = getLuaAsData(_luaState, luabridge::LuaRef::fromStack(_luaState, -1));
+			lua_pop(_luaState, retVals);
+		} else {
+			lua_pop(_luaState, retVals);
+			throw e; // we will assume syntax error and throw
+		}
 	}
-	return data;
-}
 
-bool LuaDataModel::validate(const std::string& location, const std::string& schema) {
-	return true;
-}
-
-bool LuaDataModel::isLocation(const std::string& expr) {
-	return true;
+	return data;
 }
 
 bool LuaDataModel::isValidSyntax(const std::string& expr) {
@@ -368,7 +370,9 @@ uint32_t LuaDataModel::getLength(const std::string& expr) {
 		trimmedExpr = "return(#" + trimmedExpr + ")";
 	}
 
-	int retVals = luaEval(Arabica::DOM::Element<std::string>(), trimmedExpr);
+	int retVals = luaEval(_luaState, trimmedExpr);
+
+#if 1
 
 	if (retVals == 1 && lua_isnumber(_luaState, -1)) {
 		int result = lua_tointeger(_luaState, -1);
@@ -379,6 +383,21 @@ uint32_t LuaDataModel::getLength(const std::string& expr) {
 	lua_pop(_luaState, retVals);
 	ERROR_EXECUTION_THROW("'" + expr + "' does not evaluate to an array.");
 	return 0;
+#else
+
+	if (retVals == 1) {
+		luabridge::LuaRef luaData = luabridge::LuaRef::fromStack(_luaState, -1);
+		if (luaData.isNumber()) {
+			lua_pop(_luaState, retVals);
+			return luaData.cast<int>();
+		}
+	}
+	lua_pop(_luaState, retVals);
+
+	ERROR_EXECUTION_THROW("'" + expr + "' does not evaluate to an array.");
+	return 0;
+
+#endif
 }
 
 void LuaDataModel::setForeach(const std::string& item,
@@ -390,152 +409,110 @@ void LuaDataModel::setForeach(const std::string& item,
 	const luabridge::LuaRef& arrRef = luabridge::getGlobal(_luaState, array.c_str());
 	if (arrRef.isTable()) {
 
-		// trigger syntax error for invalid items
-		int retVals = luaEval(Arabica::DOM::Element<std::string>(), "return(" + item + ");");
+		// triggers syntax error for invalid items, test 152
+		int retVals = luaEval(_luaState, item + " = " + array + "[" + toStr(iteration) + "]");
 		lua_pop(_luaState, retVals);
 
-		const luabridge::LuaRef& val = arrRef[iteration];
-		luabridge::setGlobal(_luaState, val, item.c_str());
-
 		if (index.length() > 0) {
-			// assign iteration element to index
-			luabridge::setGlobal(_luaState, iteration, index.c_str());
+			int retVals = luaEval(_luaState, index + " = " + toStr(iteration));
+			lua_pop(_luaState, retVals);
 		}
 	}
 }
 
-void LuaDataModel::eval(const Arabica::DOM::Element<std::string>& scriptElem,
-                        const std::string& expr) {
-	luaEval(scriptElem, expr);
-}
-
-int LuaDataModel::luaEval(const Arabica::DOM::Element<std::string>& scriptElem,
-                          const std::string& expr) {
-	int preStack = lua_gettop(_luaState);
-	int error = luaL_loadstring(_luaState, expr.c_str()) || lua_pcall(_luaState, 0, LUA_MULTRET, 0);
-	if (error) {
-		std::string errMsg = lua_tostring(_luaState, -1);
-		lua_pop(_luaState, 1);  /* pop error message from the stack */
-		ERROR_EXECUTION_THROW(errMsg);
-	}
-	int postStack = lua_gettop(_luaState);
-	return postStack - preStack;
-}
-
 bool LuaDataModel::isDeclared(const std::string& expr) {
 	// see: http://lua-users.org/wiki/DetectingUndefinedVariables
 	return true;
 }
 
-void LuaDataModel::assign(const Arabica::DOM::Element<std::string>& assignElem,
-                          const Arabica::DOM::Node<std::string>& node,
-                          const std::string& content) {
-	std::string key;
-	if (HAS_ATTR(assignElem, "id")) {
-		key = ATTR(assignElem, "id");
-	} else if (HAS_ATTR(assignElem, "location")) {
-		key = ATTR(assignElem, "location");
-	}
-	if (key.length() == 0) {
+
+void LuaDataModel::assign(const std::string& location, const Data& data) {
+	if (location.length() == 0) {
 		ERROR_EXECUTION_THROW("Assign element has neither id nor location");
 	}
 
 	// flags on attribute are ignored?
-	if (key.compare("_sessionid") == 0) // test 322
+	if (location.compare("_sessionid") == 0) // test 322
 		ERROR_EXECUTION_THROW("Cannot assign to _sessionId");
-	if (key.compare("_name") == 0)
+	if (location.compare("_name") == 0)
 		ERROR_EXECUTION_THROW("Cannot assign to _name");
-	if (key.compare("_ioprocessors") == 0)  // test 326
+	if (location.compare("_ioprocessors") == 0)  // test 326
 		ERROR_EXECUTION_THROW("Cannot assign to _ioprocessors");
-	if (key.compare("_invokers") == 0)
+	if (location.compare("_invokers") == 0)
 		ERROR_EXECUTION_THROW("Cannot assign to _invokers");
-	if (key.compare("_event") == 0)
+	if (location.compare("_event") == 0)
 		ERROR_EXECUTION_THROW("Cannot assign to _event");
 
-//	lua_pushnil(_luaState);
-//	lua_setglobal(_luaState, key.c_str());
+	if (data.node) {
+		ERROR_EXECUTION_THROW("Cannot assign xml nodes in lua datamodel");
 
-//	luabridge::setGlobal(_luaState, luabridge::Nil(), key.c_str());
-//	luabridge::LuaRef val = luabridge::getGlobal(_luaState, key.c_str());
-//	std::cout << val.tostring() << std::endl;
+		// TODO: DOM is prepared by swig
 
-	int retVals = 0;
+//        return SWIG_JSC_NewPointerObj(_ctx,
+//                                      (void*)node,
+//                                      SWIG_TypeDynamicCast(SWIGTYPE_p_XERCES_CPP_NAMESPACE__DOMNode,
+//                                                           SWIG_as_voidptrptr(&node)),
+//                                      0);
 
-	if (HAS_ATTR(assignElem, "expr")) {
-		retVals = luaEval(Arabica::DOM::Element<std::string>(), key + " = " + ATTR(assignElem, "expr") + ";");
-	} else if (node) {
-		ERROR_EXECUTION_THROW("Cannot assign xml nodes in lua datamodel");
-	} else if (content.size() > 0) {
-		try {
-			eval(Arabica::DOM::Element<std::string>(), key + " = " + content + ";");
-		} catch (...) {
-			eval(Arabica::DOM::Element<std::string>(), key + " = " + "\"" + spaceNormalize(content) + "\";");
-		}
+
+//        JSObjectSetProperty(_ctx, JSContextGetGlobalObject(_ctx), JSStringCreateWithUTF8CString(location.c_str()), getNodeAsValue(data.node), 0, &exception);
 	} else {
-		eval(Arabica::DOM::Element<std::string>(), key + " = " + "nil;");
-	}
 
-//	val = luabridge::getGlobal(_luaState, key.c_str());
-//	std::cout << val.tostring() << std::endl;
+		// trigger error.execution for undefined locations, test286 test311
+		int retVals = luaEval(_luaState, location + " = " + location);
+		lua_pop(_luaState, retVals);
 
-}
+		luabridge::LuaRef lua = getDataAsLua(_luaState, data);
+		luabridge::setGlobal(_luaState, lua, location.c_str());
 
-void LuaDataModel::assign(const std::string& location, const Data& data) {
-	luabridge::setGlobal(_luaState, getDataAsLua(_luaState, data), location.c_str());
-}
-
-void LuaDataModel::init(const Arabica::DOM::Element<std::string>& dataElem,
-                        const Arabica::DOM::Node<std::string>& node,
-                        const std::string& content) {
-	assign(dataElem, node, content);
+//        std::cout << Data::toJSON(evalAsData(location)) << std::endl;
+	}
 }
 
 void LuaDataModel::init(const std::string& location, const Data& data) {
+	luabridge::setGlobal(_luaState, luabridge::Nil(), location.c_str());
 	assign(location, data);
 }
 
-/**
- * The boolean expression language consists of the In predicate only. It has the
- * form 'In(id)', where id is the id of a state in the enclosing state machine.
- * The predicate must return 'true' if and only if that state is in the current
- * state configuration.
- */
-bool LuaDataModel::evalAsBool(const Arabica::DOM::Element<std::string>& node, const std::string& expr) {
+bool LuaDataModel::evalAsBool(const std::string& expr) {
 	// we need the result of the expression on the lua stack -> has to "return"!
 	std::string trimmedExpr = boost::trim_copy(expr);
-	if (!boost::starts_with(trimmedExpr, "return")) {
-		trimmedExpr = "return(" + trimmedExpr + ");";
-	}
 
-	int retVals = luaEval(Arabica::DOM::Element<std::string>(), trimmedExpr);
+	int retVals = luaEval(_luaState, "return(" + trimmedExpr + ")");
 
-	if (retVals == 1 && lua_isboolean(_luaState, -1)) {
+	if (retVals == 1) {
 		bool result = lua_toboolean(_luaState, -1);
 		lua_pop(_luaState, 1);
 		return result;
 	}
 	lua_pop(_luaState, retVals);
+
 	return false;
 }
 
+Data LuaDataModel::getAsData(const std::string& content) {
+	Data data;
+	std::string trimmedExpr = boost::trim_copy(content);
 
-std::string LuaDataModel::evalAsString(const std::string& expr) {
-	std::string trimmedExpr = boost::trim_copy(expr);
-	if (!boost::starts_with(trimmedExpr, "return")) {
-		trimmedExpr = "return(" + trimmedExpr + ")";
+	int retVals = luaEval(_luaState, "__tmp = " + content + "; return __tmp");
+	if (retVals == 1) {
+		data = getLuaAsData(_luaState, luabridge::LuaRef::fromStack(_luaState, -1));
 	}
+	lua_pop(_luaState, retVals);
 
-	int retVals = luaEval(Arabica::DOM::Element<std::string>(), trimmedExpr);
-
-	if (retVals == 1 && lua_isstring(_luaState, -1)) {
-		std::string result = lua_tostring(_luaState, -1);
-		lua_pop(_luaState, 1);
-		return result;
+	// escape as a string, this is sometimes the case with <content>
+	if (data.atom == "nil" && data.type == Data::INTERPRETED) {
+		int retVals = luaEval(_luaState, "__tmp = '" + content + "'; return __tmp");
+		if (retVals == 1) {
+			data = getLuaAsData(_luaState, luabridge::LuaRef::fromStack(_luaState, -1));
+		}
+		lua_pop(_luaState, retVals);
 	}
-	lua_pop(_luaState, retVals);
-	return "";
+
+	return data;
 }
 
+
 std::string LuaDataModel::andExpressions(std::list<std::string> exprs) {
 	std::stringstream exprSS;
 	std::list<std::string>::const_iterator listIter;
diff --git a/src/uscxml/plugins/datamodel/lua/LuaDataModel.h b/src/uscxml/plugins/datamodel/lua/LuaDataModel.h
index eb23815..4e2fd43 100644
--- a/src/uscxml/plugins/datamodel/lua/LuaDataModel.h
+++ b/src/uscxml/plugins/datamodel/lua/LuaDataModel.h
@@ -20,20 +20,20 @@
 #ifndef LUADATAMODEL_H_113E014C
 #define LUADATAMODEL_H_113E014C
 
-#include "uscxml/InterpreterInfo.h"
 #include "uscxml/plugins/DataModel.h"
 #include <list>
 
-#ifdef BUILD_AS_PLUGINS
-#include "uscxml/plugins/Plugins.h"
-#endif
-
 extern "C" {
 #include "lua.h"
 #include "lualib.h"
 #include "lauxlib.h"
 }
 
+#ifdef BUILD_AS_PLUGINS
+#include "uscxml/plugins/Plugins.h"
+#endif
+
+
 namespace uscxml {
 class Event;
 class Data;
@@ -45,7 +45,9 @@ class LuaDataModel : public DataModelImpl {
 public:
 	LuaDataModel();
 	virtual ~LuaDataModel();
-	virtual boost::shared_ptr<DataModelImpl> create(InterpreterInfo* interpreter);
+	virtual std::shared_ptr<DataModelImpl> create(DataModelCallbacks* callbacks);
+
+	virtual void addExtension(DataModelExtension* ext);
 
 	virtual std::list<std::string> getNames() {
 		std::list<std::string> names;
@@ -53,46 +55,31 @@ public:
 		return names;
 	}
 
-	virtual void initialize();
-	virtual void setEvent(const Event& event);
-
-	virtual bool validate(const std::string& location, const std::string& schema);
-	virtual bool isLocation(const std::string& expr);
 	virtual bool isValidSyntax(const std::string& expr);
 
+	virtual void setEvent(const Event& event);
+
+	// foreach
 	virtual uint32_t getLength(const std::string& expr);
 	virtual void setForeach(const std::string& item,
 	                        const std::string& array,
 	                        const std::string& index,
 	                        uint32_t iteration);
 
-	virtual void pushContext();
-	virtual void popContext();
-
-	virtual void assign(const Arabica::DOM::Element<std::string>& assignElem,
-	                    const Arabica::DOM::Node<std::string>& node,
-	                    const std::string& content);
-	virtual void assign(const std::string& location, const Data& data);
-
-	virtual void init(const Arabica::DOM::Element<std::string>& dataElem,
-	                  const Arabica::DOM::Node<std::string>& node,
-	                  const std::string& content);
-	virtual void init(const std::string& location, const Data& data);
+	virtual bool evalAsBool(const std::string& expr);
+	virtual Data evalAsData(const std::string& expr);
+	virtual Data getAsData(const std::string& content);
 
-	virtual Data getStringAsData(const std::string& content);
 	virtual bool isDeclared(const std::string& expr);
 
-	virtual void eval(const Arabica::DOM::Element<std::string>& scriptElem,
-	                  const std::string& expr);
-	virtual std::string evalAsString(const std::string& expr);
-	virtual bool evalAsBool(const Arabica::DOM::Element<std::string>& node, const std::string& expr);
+	virtual void assign(const std::string& location, const Data& data);
+	virtual void init(const std::string& location, const Data& data);
 
 	virtual std::string andExpressions(std::list<std::string>);
 
 protected:
 
-	virtual int luaEval(const Arabica::DOM::Element<std::string>& scriptElem,
-	                    const std::string& expr);
+	static int luaInFunction(lua_State * l);
 
 	lua_State* _luaState;
 };
diff --git a/src/uscxml/plugins/datamodel/lua/bindings.i b/src/uscxml/plugins/datamodel/lua/bindings.i
new file mode 100644
index 0000000..24b756b
--- /dev/null
+++ b/src/uscxml/plugins/datamodel/lua/bindings.i
@@ -0,0 +1,38 @@
+#define XERCES_HAS_CPP_NAMESPACE 1
+
+%include <std_string.i>
+
+%module LuaDOM
+
+%import "uscxml/config.h"
+%import "uscxml/Common.h"
+
+%import "xercesc/util/XercesDefs.hpp"
+%import "xercesc/util/Xerces_autoconf_config.hpp"
+
+%include "../common/bindings/dom/ignore.i"
+%include "../common/bindings/dom/defines.i"
+%include "../common/bindings/dom/typemaps-general.i"
+
+// in typemap
+%typemap(in) XMLCh * %{
+  $1 = Lua2XMLString($input);
+%}
+
+%typemap(freearg) XMLCh * %{
+  delete[] $1;
+%}
+
+// out typemap
+%typemap(out) XMLCh * %{
+  $result = XMLString2Lua($1);
+%}
+
+%include "../common/bindings/dom/dom.i"
+
+// Operators we do want
+// %rename(operator_assignment) operator=;
+%rename(operator_equal_to) operator==;
+%rename(operator_not_equal_to) operator!=;
+
+%include "../common/bindings/event.i"