]> git.ipfire.org Git - thirdparty/freeswitch.git/commitdiff
swigall
authorBrian West <brian@freeswitch.org>
Fri, 10 Sep 2010 17:35:40 +0000 (12:35 -0500)
committerBrian West <brian@freeswitch.org>
Fri, 10 Sep 2010 17:44:14 +0000 (12:44 -0500)
src/mod/languages/mod_lua/mod_lua_wrap.cpp

index 962ebe3eca625904e44e3cbc16f30e3369674f06..4bf4b6715468ee46eae95cae3e662d84e4481d53 100644 (file)
@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.29
+ * Version 1.3.35
  * 
  * 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
@@ -10,7 +10,7 @@
 
 
 #ifdef __cplusplus
-template<class T> class SwigValueWrapper {
+template<typename T> class SwigValueWrapper {
     T *tt;
 public:
     SwigValueWrapper() : tt(0) { }
@@ -23,6 +23,10 @@ public:
 private:
     SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
 };
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
 #endif
 
 /* -----------------------------------------------------------------------------
@@ -32,14 +36,14 @@ private:
 
 /* template workaround for compilers that cannot correctly implement the C++ standard */
 #ifndef SWIGTEMPLATEDISAMBIGUATOR
-# if defined(__SUNPRO_CC)
-#   if (__SUNPRO_CC <= 0x560)
-#     define SWIGTEMPLATEDISAMBIGUATOR template
-#   else
-#     define SWIGTEMPLATEDISAMBIGUATOR 
-#   endif
+# 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 
+#  define SWIGTEMPLATEDISAMBIGUATOR
 # endif
 #endif
 
@@ -118,10 +122,16 @@ private:
 #endif
 
 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
-#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
+#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
+
+
 /* -----------------------------------------------------------------------------
  * swigrun.swg
  *
@@ -131,7 +141,7 @@ private:
 
 /* 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 "2"
+#define SWIG_RUNTIME_VERSION "4"
 
 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 #ifdef SWIG_TYPE_TABLE
@@ -166,6 +176,7 @@ private:
 
 /* 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
@@ -306,10 +317,10 @@ SWIGINTERNINLINE int SWIG_CheckState(int r) {
 extern "C" {
 #endif
 
-typedef void *(*swig_converter_func)(void *);
+typedef void *(*swig_converter_func)(void *, int *);
 typedef struct swig_type_info *(*swig_dycast_func)(void **);
 
-/* Structure to store inforomation on one type */
+/* 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 */
@@ -354,7 +365,7 @@ SWIG_TypeNameComp(const char *f1, const char *l1,
     while ((*f2 == ' ') && (f2 != l2)) ++f2;
     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
   }
-  return (l1 - f1) - (l2 - f2);
+  return (int)((l1 - f1) - (l2 - f2));
 }
 
 /*
@@ -436,8 +447,8 @@ SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
   Cast a pointer up an inheritance hierarchy
 */
 SWIGRUNTIMEINLINE void *
-SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
-  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
 }
 
 /* 
@@ -708,7 +719,8 @@ extern "C" {
 
 #include "lua.h"
 #include "lauxlib.h"
-#include <assert.h>    /* for a few sanity tests */
+#include <stdlib.h>  /* for malloc */
+#include <assert.h>  /* for a few sanity tests */
 
 /* -----------------------------------------------------------------------------
  * global swig types
@@ -719,12 +731,7 @@ extern "C" {
 #define SWIG_LUA_STRING  3
 #define SWIG_LUA_POINTER 4
 #define SWIG_LUA_BINARY  5
-
-/* Structure for command table (replaced by luaLib's luaL_reg) */
-/*typedef struct {
-  const char *name;
-  lua_CFunction wrapper;
-} swig_lua_command_info;*/
+#define SWIG_LUA_CHAR    6
 
 /* Structure for variable linking table */
 typedef struct {
@@ -755,29 +762,42 @@ typedef struct {
 } swig_lua_attribute;
 
 typedef struct swig_lua_class {
-  const char         *name;
+  const char    *name;
   swig_type_info   **type;
-  lua_CFunction       constructor;
-  void              (*destructor)(void *);
-  swig_lua_method        *methods;
+  lua_CFunction  constructor;
+  void    (*destructor)(void *);
+  swig_lua_method   *methods;
   swig_lua_attribute     *attributes;
   struct swig_lua_class **bases;
+  const char **base_names;
 } swig_lua_class;
 
+/* this is the struct for wrappering all pointers in SwigLua
+*/
 typedef struct {
-  void             *ptr;
   swig_type_info   *type;
-  int               own;       /* 1 if owned & must be destroyed */
+  int     own;  /* 1 if owned & must be destroyed */
+  void        *ptr;
 } swig_lua_userdata;
 
+/* this is the struct for wrapping arbitary 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)
+#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))
@@ -788,141 +808,193 @@ typedef struct {
 #define SWIG_contract_assert(expr, msg)  \
   if (!(expr)) { lua_pushstring(L, (char *) msg); goto fail; } else
 
-
-
 /* helper #defines */
 #define SWIG_fail {goto fail;}
-#define SWIG_fail_arg(I) {lua_pushfstring(L,"argument %d incorrect/missing",I);goto fail;}
+#define SWIG_fail_arg(func_name,argnum,type) \
+  {lua_pushfstring(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) \
+  {lua_pushfstring(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))
+  (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))
+  (lua_pushstring(L, n), \
+      lua_pushcfunction(L, f), \
+      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 value 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 */
+  lua_pushstring(L,"This variable is immutable");
+  lua_error(L);
+#endif
+    return 0;   /* should not return anything */
+}
+
 /* the module.get method used for getting linked data */
 SWIGINTERN int SWIG_Lua_module_get(lua_State* L)
 {
-/*     there should be 2 params passed in
-       (1) table (not the meta table)
-       (2) string name of the attribute
-       printf("SWIG_Lua_module_get %p(%s) '%s'\n",
-                               lua_topointer(L,1),lua_typename(L,lua_type(L,1)),
-                               lua_tostring(L,2));
+/*  there should be 2 params passed in
+  (1) table (not the meta table)
+  (2) string name of the attribute
+  printf("SWIG_Lua_module_get %p(%s) '%s'\n",
+   lua_topointer(L,1),lua_typename(L,lua_type(L,1)),
+   lua_tostring(L,2));
 */
-       /* get the metatable */
-       assert(lua_istable(L,1));       /* just in case */
-       lua_getmetatable(L,1);  /* get the metatable */
-       assert(lua_istable(L,-1));      /* just in case */
-       SWIG_Lua_get_table(L,".get");   /* get the .get table */
-       lua_remove(L,3);        /* remove metatable */
-       if (lua_istable(L,-1))
-       {
-               /* look for the key in the .get table */
-               lua_pushvalue(L,2);  /* key */
-               lua_rawget(L,-2);
-               lua_remove(L,3);        /* remove .get */
-               if (lua_iscfunction(L,-1))
-               {       /* found it so call the fn & return its value */
-                       lua_call(L,0,1);
-                       return 1;
-               }
-               lua_pop(L,1);   /* remove the top */
-       }
-       lua_pop(L,1);   /* remove the .get */
-       lua_pushnil(L); /* return a nil */
+  /* get the metatable */
+  assert(lua_istable(L,1));  /* just in case */
+  lua_getmetatable(L,1);  /* get the metatable */
+  assert(lua_istable(L,-1));  /* just in case */
+  SWIG_Lua_get_table(L,".get");  /* get the .get table */
+  lua_remove(L,3);  /* remove metatable */
+  if (lua_istable(L,-1))
+  {
+    /* look for the key in the .get table */
+    lua_pushvalue(L,2);  /* key */
+    lua_rawget(L,-2);
+    lua_remove(L,3);  /* remove .get */
+    if (lua_iscfunction(L,-1))
+    {  /* found it so call the fn & return its value */
+      lua_call(L,0,1);
+      return 1;
+    }
+    lua_pop(L,1);  /* remove the top */
+  }
+  lua_pop(L,1);  /* remove the .get */
+  lua_pushnil(L);  /* return a nil */
     return 1;
 }
 
 /* the module.set method used for setting linked data */
 SWIGINTERN int SWIG_Lua_module_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
+/*  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
 */
-       /* get the metatable */
-       assert(lua_istable(L,1));       /* just in case */
-       lua_getmetatable(L,1);  /* get the metatable */
-       assert(lua_istable(L,-1));      /* just in case */
-       SWIG_Lua_get_table(L,".set");   /* get the .set table */
-       lua_remove(L,4);        /* remove metatable */
-       if (lua_istable(L,-1))
-       {
-               /* look for the key in the .set table */
-               lua_pushvalue(L,2);  /* key */
-               lua_rawget(L,-2);
-               lua_remove(L,4);        /* remove .set */
-               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 top */
-       }
-       lua_pop(L,1);   /* remove the .set */
-    return 0;
+  /* get the metatable */
+  assert(lua_istable(L,1));  /* just in case */
+  lua_getmetatable(L,1);  /* get the metatable */
+  assert(lua_istable(L,-1));  /* just in case */
+  SWIG_Lua_get_table(L,".set");  /* get the .set table */
+  lua_remove(L,4);  /* remove metatable */
+  if (lua_istable(L,-1))
+  {
+    /* look for the key in the .set table */
+    lua_pushvalue(L,2);  /* key */
+    lua_rawget(L,-2);
+    lua_remove(L,4);  /* remove .set */
+    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_settop(L,3);  /* reset back to start */
+  /* we now have the table, key & new value, so just set directly */
+  lua_rawset(L,1);  /* add direct */
+  return 0;
 }
 
 /* registering a module in lua */
 SWIGINTERN void  SWIG_Lua_module_begin(lua_State* L,const char* name)
 {
-       assert(lua_istable(L,-1));      /* just in case */
-       lua_pushstring(L,name);
-       lua_newtable(L);                                /* the table */
-       /* add meta table */
-       lua_newtable(L);                /* the meta table */
-       SWIG_Lua_add_function(L,"__index",SWIG_Lua_module_get);
-       SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_module_set);
-       lua_pushstring(L,".get");
-       lua_newtable(L);                /* the .get table */
-       lua_rawset(L,-3);       /* add .get into metatable */
-       lua_pushstring(L,".set");
-       lua_newtable(L);                /* the .set table */
-       lua_rawset(L,-3);       /* add .set into metatable */
-       lua_setmetatable(L,-2); /* sets meta table in module */
-       lua_rawset(L,-3);                  /* add module into parent */
-       SWIG_Lua_get_table(L,name);                             /* get the table back out */
+  assert(lua_istable(L,-1));  /* just in case */
+  lua_pushstring(L,name);
+  lua_newtable(L);   /* the table */
+  /* add meta table */
+  lua_newtable(L);    /* the meta table */
+  SWIG_Lua_add_function(L,"__index",SWIG_Lua_module_get);
+  SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_module_set);
+  lua_pushstring(L,".get");
+  lua_newtable(L);    /* the .get table */
+  lua_rawset(L,-3);  /* add .get into metatable */
+  lua_pushstring(L,".set");
+  lua_newtable(L);    /* the .set table */
+  lua_rawset(L,-3);  /* add .set into metatable */
+  lua_setmetatable(L,-2);  /* sets meta table in module */
+  lua_rawset(L,-3);        /* add module into parent */
+  SWIG_Lua_get_table(L,name);   /* get the table back out */
 }
 
 /* ending the register */
 SWIGINTERN void  SWIG_Lua_module_end(lua_State* L)
 {
-       lua_pop(L,1);                      /* tidy stack (remove module) */
+  lua_pop(L,1);       /* tidy stack (remove module) */
 }
 
 /* adding a linked variable to the module */
 SWIGINTERN void SWIG_Lua_module_add_variable(lua_State* L,const char* name,lua_CFunction getFn,lua_CFunction setFn)
 {
-       assert(lua_istable(L,-1));      /* just in case */
-       lua_getmetatable(L,-1); /* get the metatable */
-       assert(lua_istable(L,-1));      /* just in case */
-       SWIG_Lua_get_table(L,".get"); /* find the .get table */
-       assert(lua_istable(L,-1));      /* should be a table: */
-       SWIG_Lua_add_function(L,name,getFn);
-       lua_pop(L,1);                      /* tidy stack (remove table) */
-       if (setFn)      /* if there is a set fn */
-       {
-               SWIG_Lua_get_table(L,".set"); /* find the .set table */
-               assert(lua_istable(L,-1));      /* should be a table: */
-               SWIG_Lua_add_function(L,name,setFn);
-               lua_pop(L,1);                      /* tidy stack (remove table) */
-       }
-       lua_pop(L,1);                      /* tidy stack (remove meta) */
+  assert(lua_istable(L,-1));  /* just in case */
+  lua_getmetatable(L,-1);  /* get the metatable */
+  assert(lua_istable(L,-1));  /* just in case */
+  SWIG_Lua_get_table(L,".get"); /* find the .get table */
+  assert(lua_istable(L,-1));  /* should be a table: */
+  SWIG_Lua_add_function(L,name,getFn);
+  lua_pop(L,1);       /* tidy stack (remove table) */
+  if (setFn)  /* if there is a set fn */
+  {
+    SWIG_Lua_get_table(L,".set"); /* find the .set table */
+    assert(lua_istable(L,-1));  /* should be a table: */
+    SWIG_Lua_add_function(L,name,setFn);
+    lua_pop(L,1);       /* tidy stack (remove table) */
+  }
+  lua_pop(L,1);       /* tidy stack (remove meta) */
 }
 
 /* adding a function module */
 SWIGINTERN void  SWIG_Lua_module_add_function(lua_State* L,const char* name,lua_CFunction fn)
 {
-       SWIG_Lua_add_function(L,name,fn);
+  SWIG_Lua_add_function(L,name,fn);
 }
 
 /* -----------------------------------------------------------------------------
@@ -932,307 +1004,383 @@ SWIGINTERN void  SWIG_Lua_module_add_function(lua_State* L,const char* name,lua_
 /* 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
+/*  there should be 2 params passed in
+  (1) userdata (not the meta table)
+  (2) string name of the attribute
 */
-       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,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,1);  /* the userdata */
-               lua_call(L,1,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_iscfunction(L,-1))
-       {       /* 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 */
-       /* 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,1);  /* the userdata */
-               lua_pushvalue(L,2);  /* the parameter */
-               lua_call(L,2,1);        /* 2 value in (userdata),1 out (result) */
-               lua_remove(L,-2); /* stack tidy, remove metatable */
-               return 1;
-       }
-       return 0;       /* sorry not known */
+  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,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,1);  /* the userdata */
+    lua_call(L,1,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: 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 */
+    return 1;
+  }
+  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,1);  /* the userdata */
+    lua_pushvalue(L,2);  /* the parameter */
+    lua_call(L,2,1);  /* 2 value in (userdata),1 out (result) */
+    lua_remove(L,-2); /* stack tidy, remove metatable */
+    return 1;
+  }
+  return 0;  /* sorry not known */
 }
 
 /* the class.set method, performs the lookup of class attributes */
 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
+/*  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
 printf("SWIG_Lua_class_set %p(%s) '%s' %p(%s)\n",
-                       lua_topointer(L,1),lua_typename(L,lua_type(L,1)),
-                       lua_tostring(L,2),
-                       lua_topointer(L,3),lua_typename(L,lua_type(L,3)));*/
-
-       assert(lua_isuserdata(L,1));    /* just in case */
-       lua_getmetatable(L,1);          /* get the meta table */
-       assert(lua_istable(L,-1));      /* just in case */
-
-       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,1);  /* userdata */
-                       lua_pushvalue(L,3);  /* value */
-                       lua_call(L,2,0);
-                       return 0;
-               }
-               lua_pop(L,1);   /* remove the value */
-       }
-       lua_pop(L,1);   /* remove the value .set table */
-       /* 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,1);  /* the userdata */
-               lua_pushvalue(L,2);  /* the parameter */
-               lua_pushvalue(L,3);  /* the value */
-               lua_call(L,3,0);        /* 3 values in ,0 out */
-               lua_remove(L,-2); /* stack tidy, remove metatable */
-               return 1;
-       }
-       return 0;
+      lua_topointer(L,1),lua_typename(L,lua_type(L,1)),
+      lua_tostring(L,2),
+      lua_topointer(L,3),lua_typename(L,lua_type(L,3)));*/
+
+  assert(lua_isuserdata(L,1));  /* just in case */
+  lua_getmetatable(L,1);    /* get the meta table */
+  assert(lua_istable(L,-1));  /* just in case */
+
+  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,1);  /* userdata */
+      lua_pushvalue(L,3);  /* value */
+      lua_call(L,2,0);
+      return 0;
+    }
+    lua_pop(L,1);  /* remove the value */
+  }
+  lua_pop(L,1);  /* remove the value .set table */
+  /* 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,1);  /* the userdata */
+    lua_pushvalue(L,2);  /* the parameter */
+    lua_pushvalue(L,3);  /* the value */
+    lua_call(L,3,0);  /* 3 values in ,0 out */
+    lua_remove(L,-2); /* stack tidy, remove metatable */
+    return 1;
+  }
+  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;
+/*  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;
 }
 
 /* gets the swig class 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 */
-               lua_pushstring(L,"SWIG");
-               lua_newtable(L);
-               lua_rawset(L,LUA_REGISTRYINDEX);
-               /* then get it */
-               lua_pushstring(L,"SWIG");
-               lua_rawget(L,LUA_REGISTRYINDEX);
-       }
+  /* 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 */
+    lua_pushstring(L,"SWIG");
+    lua_newtable(L);
+    lua_rawset(L,LUA_REGISTRYINDEX);
+    /* then get it */
+    lua_pushstring(L,"SWIG");
+    lua_rawget(L,LUA_REGISTRYINDEX);
+  }
 }
 
 /* helper fn 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) */
+  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) */
 }
 
 /* helper add a variable to a registered class */
 SWIGINTERN void  SWIG_Lua_add_class_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) */
-       }
+  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 details (attributes & operations) */
 SWIGINTERN void  SWIG_Lua_add_class_details(lua_State* L,swig_lua_class* clss)
 {
-       int i;
-       /* call all the base classes first: we can then override these later: */
-       for(i=0;clss->bases[i];i++)
-       {
-               SWIG_Lua_add_class_details(L,clss->bases[i]);
-       }
-       /* add fns */
-       for(i=0;clss->attributes[i].name;i++){
-               SWIG_Lua_add_class_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].method);
-       }
-       lua_pop(L,1);                      /* tidy stack (remove table) */
-       /*      add operator overloads
-               these look ANY method which start with "__" and assume they
-               are operator overloads & add them to the metatable
-               (this might mess up is someone defines a method __gc (the destructor)*/
-       for(i=0;clss->methods[i].name;i++){
-               if (clss->methods[i].name[0]=='_' && clss->methods[i].name[1]=='_'){
-                       SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].method);
-               }
-       }
+  int i;
+  /* call all the base classes first: we can then override these later: */
+  for(i=0;clss->bases[i];i++)
+  {
+    SWIG_Lua_add_class_details(L,clss->bases[i]);
+  }
+  /* add fns */
+  for(i=0;clss->attributes[i].name;i++){
+    SWIG_Lua_add_class_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].method);
+  }
+  lua_pop(L,1);       /* tidy stack (remove table) */
+  /*   add operator overloads
+    these look ANY method which start with "__" and assume they
+    are operator overloads & add them to the metatable
+    (this might mess up is someone defines a method __gc (the destructor)*/
+  for(i=0;clss->methods[i].name;i++){
+    if (clss->methods[i].name[0]=='_' && clss->methods[i].name[1]=='_'){
+      SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].method);
+    }
+  }
+}
+
+/* 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;
+    }
+  }    
 }
 
 /* performs the entire class registration process */
 SWIGINTERN void  SWIG_Lua_class_register(lua_State* L,swig_lua_class* clss)
 {
-/*     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)
-               SWIG_Lua_add_function(L,clss->name,clss->constructor);
-
-       SWIG_Lua_get_class_registry(L); /* get the registry */
-       lua_pushstring(L,clss->name);   /* get the name */
-       lua_newtable(L);                /* create the metatable */
-       /* add string of class name called ".type" */
-       lua_pushstring(L,".type");
-       lua_pushstring(L,clss->name);
-       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);
-       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) */
-
-       SWIG_Lua_get_class_metatable(L,clss->name);
-       SWIG_Lua_add_class_details(L,clss);     /* recursive adding of details (atts & ops) */
-       lua_pop(L,1);           /* tidy stack (remove class metatable) */
+  /*  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)
+    SWIG_Lua_add_function(L,clss->name,clss->constructor);
+
+  SWIG_Lua_get_class_registry(L);  /* get the registry */
+  lua_pushstring(L,clss->name);  /* get the name */
+  lua_newtable(L);    /* create the metatable */
+  /* add string of class name called ".type" */
+  lua_pushstring(L,".type");
+  lua_pushstring(L,clss->name);
+  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);
+  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) */
+
+  SWIG_Lua_get_class_metatable(L,clss->name);
+  SWIG_Lua_add_class_details(L,clss);  /* recursive adding of details (atts & ops) */
+  lua_pop(L,1);      /* tidy stack (remove class metatable) */
 }
 
 /* -----------------------------------------------------------------------------
  * 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))->name);
+    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 (type->clientdata)   /* there is clientdata: so add the metatable */
-       {
-               SWIG_Lua_get_class_metatable(L,((swig_lua_class*)(type->clientdata))->name);
-               if (lua_istable(L,-1))
-               {
-                       lua_setmetatable(L,-2);
-               }
-               else
-               {
-                       lua_pop(L,1);
-               }
-       }
+  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;
+  _SWIG_Lua_AddMetatable(L,type); /* add metatable */
 }
 
 /* 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;
-       usr=(swig_lua_userdata*)lua_touserdata(L,index);        /* get data */
-       if (usr)
-       {
-               cast=SWIG_TypeCheckStruct(usr->type,type);
-               if (cast)
-               {
-                       *ptr=SWIG_TypeCast(cast,usr->ptr);
-                       return 0;       /* ok */
-               }
-       }
-       return 1;       /* error */
+  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_ConvertPtr(L,index,&result,type,flags)){
-               lua_pushfstring(L,"Error in %s, expected a %s at argument number %d\n",
-                       func_name,(type && type->str)?type->str:"void*",argnum);
-               lua_error(L);
-       }
-       return result;
+       int argnum,const char* func_name){
+  void* result;
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,index,&result,type,flags))){
+    lua_pushfstring(L,"Error in %s, expected a %s at argument number %d\n",
+      func_name,(type && type->str)?type->str:"void*",argnum);
+    lua_error(L);
+  }
+  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,1);  /* 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)
 {
-       swig_lua_userdata* usr;
-       if (!lua_isuserdata(L,1))       /* just in case */
-               return 0;       /* nil reply */
-       usr=(swig_lua_userdata*)lua_touserdata(L,1);    /* get data */
-       lua_pushstring(L,usr->type->name);
-       return 1;
+  lua_pushstring(L,SWIG_Lua_typename(L,1));
+  return 1;
 }
 
 /* lua callable function to compare userdata's value
@@ -1240,18 +1388,18 @@ the issue is that two userdata may point to the same thing
 but to lua, they are different objects */
 SWIGRUNTIME int SWIG_Lua_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);
-       lua_pushboolean(L,result);
-       return 1;
+  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;
 }
 
-
 /* -----------------------------------------------------------------------------
  * global variable support code: class/struct typemap functions
  * ----------------------------------------------------------------------------- */
@@ -1264,12 +1412,17 @@ SWIG_Lua_InstallConstants(lua_State* L, swig_lua_const_info constants[]) {
     switch(constants[i].type) {
     case SWIG_LUA_INT:
       lua_pushstring(L,constants[i].name);
-      lua_pushnumber(L,(double)constants[i].lvalue);
+      lua_pushnumber(L,(lua_Number)constants[i].lvalue);
       lua_rawset(L,-3);
       break;
     case SWIG_LUA_FLOAT:
       lua_pushstring(L,constants[i].name);
-      lua_pushnumber(L,(double)constants[i].dvalue);
+      lua_pushnumber(L,(lua_Number)constants[i].dvalue);
+      lua_rawset(L,-3);
+      break;
+    case SWIG_LUA_CHAR:
+      lua_pushstring(L,constants[i].name);
+      lua_pushfstring(L,"%c",(char)constants[i].lvalue);
       lua_rawset(L,-3);
       break;
     case SWIG_LUA_STRING:
@@ -1283,8 +1436,9 @@ SWIG_Lua_InstallConstants(lua_State* L, swig_lua_const_info constants[]) {
       lua_rawset(L,-3);
       break;
     case SWIG_LUA_BINARY:
-    /* TODO?? */
-/*      obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); */
+      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;
@@ -1292,25 +1446,34 @@ SWIG_Lua_InstallConstants(lua_State* L, swig_lua_const_info constants[]) {
   }
 }
 
-/* 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;
-}
+/* -----------------------------------------------------------------------------
+ * executing lua code from within the wrapper
+ * ----------------------------------------------------------------------------- */
 
-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);
-}
+#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 a really simple way of calling lua from C
+Unfortunately lua keeps changing its API's, so we need a conditional compile
+In lua 5.0.X its lua_dostring()
+In lua 5.1.X its 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
 }
@@ -1321,15 +1484,15 @@ SWIG_Lua_SetModule(lua_State* L, swig_module_info *module) {
 
 /* -------- TYPES TABLE (BEGIN) -------- */
 
-#define SWIGTYPE_SWIGLUA_FN swig_types[0]
-#define SWIGTYPE_p_API swig_types[1]
-#define SWIGTYPE_p_CoreSession swig_types[2]
-#define SWIGTYPE_p_DTMF swig_types[3]
-#define SWIGTYPE_p_Event swig_types[4]
-#define SWIGTYPE_p_EventConsumer swig_types[5]
-#define SWIGTYPE_p_IVRMenu swig_types[6]
-#define SWIGTYPE_p_LUA__Dbh swig_types[7]
-#define SWIGTYPE_p_LUA__Session swig_types[8]
+#define SWIGTYPE_p_API swig_types[0]
+#define SWIGTYPE_p_CoreSession swig_types[1]
+#define SWIGTYPE_p_DTMF swig_types[2]
+#define SWIGTYPE_p_Event swig_types[3]
+#define SWIGTYPE_p_EventConsumer swig_types[4]
+#define SWIGTYPE_p_IVRMenu swig_types[5]
+#define SWIGTYPE_p_LUA__Dbh swig_types[6]
+#define SWIGTYPE_p_LUA__Session swig_types[7]
+#define SWIGTYPE_p_SWIGLUA_FN swig_types[8]
 #define SWIGTYPE_p_Stream swig_types[9]
 #define SWIGTYPE_p_input_callback_state swig_types[10]
 #define SWIGTYPE_p_lua_State swig_types[11]
@@ -1350,22 +1513,23 @@ SWIG_Lua_SetModule(lua_State* L, swig_module_info *module) {
 #define SWIGTYPE_p_switch_stream_handle_t swig_types[26]
 #define SWIGTYPE_p_uint32_t swig_types[27]
 #define SWIGTYPE_p_void swig_types[28]
-#define SWIGTYPE_switch_call_cause_t swig_types[29]
-#define SWIGTYPE_switch_channel_state_t swig_types[30]
-#define SWIGTYPE_switch_event_types_t swig_types[31]
-#define SWIGTYPE_switch_input_type_t swig_types[32]
-#define SWIGTYPE_switch_priority_t swig_types[33]
-#define SWIGTYPE_uint32_t swig_types[34]
-static swig_type_info *swig_types[36];
-static swig_module_info swig_module = {swig_types, 35, 0, 0, 0, 0};
+static swig_type_info *swig_types[30];
+static swig_module_info swig_module = {swig_types, 29, 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_init    Freeswitch_Init
-#define SWIG_name    "freeswitch"
-#define SWIG_import  luaopen_freeswitch
+#define SWIG_name      "freeswitch"
+#define SWIG_init      luaopen_freeswitch
+#define SWIG_init_user luaopen_freeswitch_user
+
+#define SWIG_LUACODE   luaopen_freeswitch_luacode
+
+
+namespace swig {
+typedef struct{} LANGUAGE_OBJ;
+}
 
 
 #include "switch.h"
@@ -1380,15 +1544,18 @@ static int _wrap_consoleLog(lua_State* L) {
   char *arg1 = (char *) 0 ;
   char *arg2 = (char *) 0 ;
   
-  if(!lua_isstring(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1 = (char*)lua_tostring(L, 1);
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("consoleLog",2,2)
+  if(!lua_isstring(L,1)) SWIG_fail_arg("consoleLog",1,"char *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("consoleLog",2,"char *");
+  arg1 = (char *)lua_tostring(L, 1);
+  arg2 = (char *)lua_tostring(L, 2);
   consoleLog(arg1,arg2);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1399,13 +1566,16 @@ static int _wrap_consoleCleanLog(lua_State* L) {
   int SWIG_arg = -1;
   char *arg1 = (char *) 0 ;
   
-  if(!lua_isstring(L,1)) SWIG_fail_arg(1);
-  arg1 = (char*)lua_tostring(L, 1);
+  SWIG_check_num_args("consoleCleanLog",1,1)
+  if(!lua_isstring(L,1)) SWIG_fail_arg("consoleCleanLog",1,"char *");
+  arg1 = (char *)lua_tostring(L, 1);
   consoleCleanLog(arg1);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1432,32 +1602,37 @@ static int _wrap_new_IVRMenu(lua_State* L) {
   int arg16 ;
   IVRMenu *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(!lua_isstring(L,3)) SWIG_fail_arg(3);
-  if(!lua_isstring(L,4)) SWIG_fail_arg(4);
-  if(!lua_isstring(L,5)) SWIG_fail_arg(5);
-  if(!lua_isstring(L,6)) SWIG_fail_arg(6);
-  if(!lua_isstring(L,7)) SWIG_fail_arg(7);
-  if(!lua_isstring(L,8)) SWIG_fail_arg(8);
-  if(!lua_isstring(L,9)) SWIG_fail_arg(9);
-  if(!lua_isstring(L,10)) SWIG_fail_arg(10);
-  if(!lua_isnumber(L,11)) SWIG_fail_arg(11);
-  if(!lua_isnumber(L,12)) SWIG_fail_arg(12);
-  if(!lua_isnumber(L,13)) SWIG_fail_arg(13);
-  if(!lua_isnumber(L,14)) SWIG_fail_arg(14);
-  if(!lua_isnumber(L,15)) SWIG_fail_arg(15);
-  if(!lua_isnumber(L,16)) SWIG_fail_arg(16);
-  arg1=(IVRMenu *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_IVRMenu,0,1,"new_IVRMenu");
-  arg2 = (char*)lua_tostring(L, 2);
-  arg3 = (char*)lua_tostring(L, 3);
-  arg4 = (char*)lua_tostring(L, 4);
-  arg5 = (char*)lua_tostring(L, 5);
-  arg6 = (char*)lua_tostring(L, 6);
-  arg7 = (char*)lua_tostring(L, 7);
-  arg8 = (char*)lua_tostring(L, 8);
-  arg9 = (char*)lua_tostring(L, 9);
-  arg10 = (char*)lua_tostring(L, 10);
+  SWIG_check_num_args("IVRMenu",16,16)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("IVRMenu",1,"IVRMenu *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("IVRMenu",2,"char const *");
+  if(!lua_isstring(L,3)) SWIG_fail_arg("IVRMenu",3,"char const *");
+  if(!lua_isstring(L,4)) SWIG_fail_arg("IVRMenu",4,"char const *");
+  if(!lua_isstring(L,5)) SWIG_fail_arg("IVRMenu",5,"char const *");
+  if(!lua_isstring(L,6)) SWIG_fail_arg("IVRMenu",6,"char const *");
+  if(!lua_isstring(L,7)) SWIG_fail_arg("IVRMenu",7,"char const *");
+  if(!lua_isstring(L,8)) SWIG_fail_arg("IVRMenu",8,"char const *");
+  if(!lua_isstring(L,9)) SWIG_fail_arg("IVRMenu",9,"char const *");
+  if(!lua_isstring(L,10)) SWIG_fail_arg("IVRMenu",10,"char const *");
+  if(!lua_isnumber(L,11)) SWIG_fail_arg("IVRMenu",11,"int");
+  if(!lua_isnumber(L,12)) SWIG_fail_arg("IVRMenu",12,"int");
+  if(!lua_isnumber(L,13)) SWIG_fail_arg("IVRMenu",13,"int");
+  if(!lua_isnumber(L,14)) SWIG_fail_arg("IVRMenu",14,"int");
+  if(!lua_isnumber(L,15)) SWIG_fail_arg("IVRMenu",15,"int");
+  if(!lua_isnumber(L,16)) SWIG_fail_arg("IVRMenu",16,"int");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_IVRMenu,0))){
+    SWIG_fail_ptr("new_IVRMenu",1,SWIGTYPE_p_IVRMenu);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
+  arg3 = (char *)lua_tostring(L, 3);
+  arg4 = (char *)lua_tostring(L, 4);
+  arg5 = (char *)lua_tostring(L, 5);
+  arg6 = (char *)lua_tostring(L, 6);
+  arg7 = (char *)lua_tostring(L, 7);
+  arg8 = (char *)lua_tostring(L, 8);
+  arg9 = (char *)lua_tostring(L, 9);
+  arg10 = (char *)lua_tostring(L, 10);
   arg11 = (int)lua_tonumber(L, 11);
   arg12 = (int)lua_tonumber(L, 12);
   arg13 = (int)lua_tonumber(L, 13);
@@ -1469,6 +1644,8 @@ static int _wrap_new_IVRMenu(lua_State* L) {
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_IVRMenu,1); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1479,14 +1656,21 @@ static int _wrap_delete_IVRMenu(lua_State* L) {
   int SWIG_arg = -1;
   IVRMenu *arg1 = (IVRMenu *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(IVRMenu *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_IVRMenu,0,1,"delete_IVRMenu");
+  SWIG_check_num_args("IVRMenu",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("IVRMenu",1,"IVRMenu *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_IVRMenu,SWIG_POINTER_DISOWN))){
+    SWIG_fail_ptr("delete_IVRMenu",1,SWIGTYPE_p_IVRMenu);
+  }
+  
   delete arg1;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1500,19 +1684,26 @@ static int _wrap_IVRMenu_bindAction(lua_State* L) {
   char *arg3 = (char *) 0 ;
   char *arg4 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(!lua_isstring(L,3)) SWIG_fail_arg(3);
-  if(!lua_isstring(L,4)) SWIG_fail_arg(4);
-  arg1=(IVRMenu *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_IVRMenu,0,1,"IVRMenu_bindAction");
-  arg2 = (char*)lua_tostring(L, 2);
-  arg3 = (char*)lua_tostring(L, 3);
-  arg4 = (char*)lua_tostring(L, 4);
+  SWIG_check_num_args("bindAction",4,4)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("bindAction",1,"IVRMenu *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("bindAction",2,"char *");
+  if(!lua_isstring(L,3)) SWIG_fail_arg("bindAction",3,"char const *");
+  if(!lua_isstring(L,4)) SWIG_fail_arg("bindAction",4,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_IVRMenu,0))){
+    SWIG_fail_ptr("IVRMenu_bindAction",1,SWIGTYPE_p_IVRMenu);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
+  arg3 = (char *)lua_tostring(L, 3);
+  arg4 = (char *)lua_tostring(L, 4);
   (arg1)->bindAction(arg2,(char const *)arg3,(char const *)arg4);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1525,17 +1716,28 @@ static int _wrap_IVRMenu_execute(lua_State* L) {
   CoreSession *arg2 = (CoreSession *) 0 ;
   char *arg3 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  if(!lua_isstring(L,3)) SWIG_fail_arg(3);
-  arg1=(IVRMenu *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_IVRMenu,0,1,"IVRMenu_execute");
-  arg2=(CoreSession *)SWIG_MustGetPtr(L,2,SWIGTYPE_p_CoreSession,0,2,"IVRMenu_execute");
-  arg3 = (char*)lua_tostring(L, 3);
+  SWIG_check_num_args("execute",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("execute",1,"IVRMenu *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("execute",2,"CoreSession *");
+  if(!lua_isstring(L,3)) SWIG_fail_arg("execute",3,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_IVRMenu,0))){
+    SWIG_fail_ptr("IVRMenu_execute",1,SWIGTYPE_p_IVRMenu);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("IVRMenu_execute",2,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg3 = (char *)lua_tostring(L, 3);
   (arg1)->execute(arg2,(char const *)arg3);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1555,17 +1757,21 @@ static swig_lua_attribute swig_IVRMenu_attributes[] = {
     {0,0,0}
 };
 static swig_lua_class *swig_IVRMenu_bases[] = {0};
-swig_lua_class _wrap_class_IVRMenu = { "IVRMenu", &SWIGTYPE_p_IVRMenu,_wrap_new_IVRMenu, swig_delete_IVRMenu, swig_IVRMenu_methods, swig_IVRMenu_attributes, swig_IVRMenu_bases };
+static const char *swig_IVRMenu_base_names[] = {0};
+static swig_lua_class _wrap_class_IVRMenu = { "IVRMenu", &SWIGTYPE_p_IVRMenu,_wrap_new_IVRMenu, swig_delete_IVRMenu, swig_IVRMenu_methods, swig_IVRMenu_attributes, swig_IVRMenu_bases, swig_IVRMenu_base_names };
 
 static int _wrap_new_API(lua_State* L) {
   int SWIG_arg = -1;
   API *result = 0 ;
   
+  SWIG_check_num_args("API",0,0)
   result = (API *)new API();
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_API,1); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1576,14 +1782,21 @@ static int _wrap_delete_API(lua_State* L) {
   int SWIG_arg = -1;
   API *arg1 = (API *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(API *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_API,0,1,"delete_API");
+  SWIG_check_num_args("API",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("API",1,"API *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_API,SWIG_POINTER_DISOWN))){
+    SWIG_fail_ptr("delete_API",1,SWIGTYPE_p_API);
+  }
+  
   delete arg1;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1597,19 +1810,26 @@ static int _wrap_API_execute(lua_State* L) {
   char *arg3 = (char *) NULL ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(lua_gettop(L)>=3 && !lua_isstring(L,3)) SWIG_fail_arg(3);
-  arg1=(API *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_API,0,1,"API_execute");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("execute",2,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("execute",1,"API *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("execute",2,"char const *");
+  if(lua_gettop(L)>=3 && !lua_isstring(L,3)) SWIG_fail_arg("execute",3,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_API,0))){
+    SWIG_fail_ptr("API_execute",1,SWIGTYPE_p_API);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   if(lua_gettop(L)>=3){
-    arg3 = (char*)lua_tostring(L, 3);
+    arg3 = (char *)lua_tostring(L, 3);
   }
   result = (char *)(arg1)->execute((char const *)arg2,(char const *)arg3);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1622,15 +1842,22 @@ static int _wrap_API_executeString(lua_State* L) {
   char *arg2 = (char *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(API *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_API,0,1,"API_executeString");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("executeString",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("executeString",1,"API *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("executeString",2,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_API,0))){
+    SWIG_fail_ptr("API_executeString",1,SWIGTYPE_p_API);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   result = (char *)(arg1)->executeString((char const *)arg2);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1642,13 +1869,20 @@ static int _wrap_API_getTime(lua_State* L) {
   API *arg1 = (API *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(API *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_API,0,1,"API_getTime");
+  SWIG_check_num_args("getTime",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("getTime",1,"API *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_API,0))){
+    SWIG_fail_ptr("API_getTime",1,SWIGTYPE_p_API);
+  }
+  
   result = (char *)(arg1)->getTime();
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1669,23 +1903,31 @@ static swig_lua_attribute swig_API_attributes[] = {
     {0,0,0}
 };
 static swig_lua_class *swig_API_bases[] = {0};
-swig_lua_class _wrap_class_API = { "API", &SWIGTYPE_p_API,_wrap_new_API, swig_delete_API, swig_API_methods, swig_API_attributes, swig_API_bases };
+static const char *swig_API_base_names[] = {0};
+static swig_lua_class _wrap_class_API = { "API", &SWIGTYPE_p_API,_wrap_new_API, swig_delete_API, swig_API_methods, swig_API_attributes, swig_API_bases, swig_API_base_names };
 
 static int _wrap_input_callback_state_t_function_set(lua_State* L) {
   int SWIG_arg = -1;
   input_callback_state_t *arg1 = (input_callback_state_t *) 0 ;
   void *arg2 = (void *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(input_callback_state_t *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_input_callback_state,0,1,"input_callback_state_t_function_set");
-  arg2=((swig_lua_userdata*)(lua_touserdata(L,2)))->ptr;
+  SWIG_check_num_args("function",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("function",1,"input_callback_state_t *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("function",2,"void *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_input_callback_state,0))){
+    SWIG_fail_ptr("input_callback_state_t_function_set",1,SWIGTYPE_p_input_callback_state);
+  }
+  
+  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"input_callback_state_t_function_set");
   if (arg1) (arg1)->function = arg2;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1697,13 +1939,20 @@ static int _wrap_input_callback_state_t_function_get(lua_State* L) {
   input_callback_state_t *arg1 = (input_callback_state_t *) 0 ;
   void *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(input_callback_state_t *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_input_callback_state,0,1,"input_callback_state_t_function_get");
+  SWIG_check_num_args("function",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("function",1,"input_callback_state_t *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_input_callback_state,0))){
+    SWIG_fail_ptr("input_callback_state_t_function_get",1,SWIGTYPE_p_input_callback_state);
+  }
+  
   result = (void *) ((arg1)->function);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_void,0); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1715,16 +1964,23 @@ static int _wrap_input_callback_state_t_threadState_set(lua_State* L) {
   input_callback_state_t *arg1 = (input_callback_state_t *) 0 ;
   void *arg2 = (void *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(input_callback_state_t *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_input_callback_state,0,1,"input_callback_state_t_threadState_set");
-  arg2=((swig_lua_userdata*)(lua_touserdata(L,2)))->ptr;
+  SWIG_check_num_args("threadState",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("threadState",1,"input_callback_state_t *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("threadState",2,"void *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_input_callback_state,0))){
+    SWIG_fail_ptr("input_callback_state_t_threadState_set",1,SWIGTYPE_p_input_callback_state);
+  }
+  
+  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"input_callback_state_t_threadState_set");
   if (arg1) (arg1)->threadState = arg2;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1736,13 +1992,20 @@ static int _wrap_input_callback_state_t_threadState_get(lua_State* L) {
   input_callback_state_t *arg1 = (input_callback_state_t *) 0 ;
   void *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(input_callback_state_t *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_input_callback_state,0,1,"input_callback_state_t_threadState_get");
+  SWIG_check_num_args("threadState",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("threadState",1,"input_callback_state_t *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_input_callback_state,0))){
+    SWIG_fail_ptr("input_callback_state_t_threadState_get",1,SWIGTYPE_p_input_callback_state);
+  }
+  
   result = (void *) ((arg1)->threadState);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_void,0); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1754,16 +2017,23 @@ static int _wrap_input_callback_state_t_extra_set(lua_State* L) {
   input_callback_state_t *arg1 = (input_callback_state_t *) 0 ;
   void *arg2 = (void *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(input_callback_state_t *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_input_callback_state,0,1,"input_callback_state_t_extra_set");
-  arg2=((swig_lua_userdata*)(lua_touserdata(L,2)))->ptr;
+  SWIG_check_num_args("extra",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("extra",1,"input_callback_state_t *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("extra",2,"void *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_input_callback_state,0))){
+    SWIG_fail_ptr("input_callback_state_t_extra_set",1,SWIGTYPE_p_input_callback_state);
+  }
+  
+  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"input_callback_state_t_extra_set");
   if (arg1) (arg1)->extra = arg2;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1775,13 +2045,20 @@ static int _wrap_input_callback_state_t_extra_get(lua_State* L) {
   input_callback_state_t *arg1 = (input_callback_state_t *) 0 ;
   void *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(input_callback_state_t *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_input_callback_state,0,1,"input_callback_state_t_extra_get");
+  SWIG_check_num_args("extra",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("extra",1,"input_callback_state_t *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_input_callback_state,0))){
+    SWIG_fail_ptr("input_callback_state_t_extra_get",1,SWIGTYPE_p_input_callback_state);
+  }
+  
   result = (void *) ((arg1)->extra);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_void,0); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1793,15 +2070,20 @@ static int _wrap_input_callback_state_t_funcargs_set(lua_State* L) {
   input_callback_state_t *arg1 = (input_callback_state_t *) 0 ;
   char *arg2 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(input_callback_state_t *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_input_callback_state,0,1,"input_callback_state_t_funcargs_set");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("funcargs",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("funcargs",1,"input_callback_state_t *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("funcargs",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_input_callback_state,0))){
+    SWIG_fail_ptr("input_callback_state_t_funcargs_set",1,SWIGTYPE_p_input_callback_state);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   {
     if (arg1->funcargs) delete [] arg1->funcargs;
     if (arg2) {
-      arg1->funcargs = (char *) (new char[strlen(arg2)+1]);
-      strcpy((char *) arg1->funcargs,arg2);
+      arg1->funcargs = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->funcargs, (const char *)arg2);
     } else {
       arg1->funcargs = 0;
     }
@@ -1810,6 +2092,8 @@ static int _wrap_input_callback_state_t_funcargs_set(lua_State* L) {
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1821,13 +2105,20 @@ static int _wrap_input_callback_state_t_funcargs_get(lua_State* L) {
   input_callback_state_t *arg1 = (input_callback_state_t *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(input_callback_state_t *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_input_callback_state,0,1,"input_callback_state_t_funcargs_get");
+  SWIG_check_num_args("funcargs",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("funcargs",1,"input_callback_state_t *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_input_callback_state,0))){
+    SWIG_fail_ptr("input_callback_state_t_funcargs_get",1,SWIGTYPE_p_input_callback_state);
+  }
+  
   result = (char *) ((arg1)->funcargs);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1838,11 +2129,14 @@ static int _wrap_new_input_callback_state_t(lua_State* L) {
   int SWIG_arg = -1;
   input_callback_state_t *result = 0 ;
   
+  SWIG_check_num_args("input_callback_state_t::input_callback_state_t",0,0)
   result = (input_callback_state_t *)new input_callback_state_t();
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_input_callback_state,1); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1853,14 +2147,21 @@ static int _wrap_delete_input_callback_state_t(lua_State* L) {
   int SWIG_arg = -1;
   input_callback_state_t *arg1 = (input_callback_state_t *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(input_callback_state_t *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_input_callback_state,0,1,"delete_input_callback_state_t");
+  SWIG_check_num_args("input_callback_state_t::~input_callback_state_t",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("input_callback_state_t::~input_callback_state_t",1,"input_callback_state_t *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_input_callback_state,SWIG_POINTER_DISOWN))){
+    SWIG_fail_ptr("delete_input_callback_state_t",1,SWIGTYPE_p_input_callback_state);
+  }
+  
   delete arg1;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1875,30 +2176,38 @@ static swig_lua_method swig_input_callback_state_t_methods[] = {
     {0,0}
 };
 static swig_lua_attribute swig_input_callback_state_t_attributes[] = {
-    { "function",_wrap_input_callback_state_t_function_get, _wrap_input_callback_state_t_function_set},
-    { "threadState",_wrap_input_callback_state_t_threadState_get, _wrap_input_callback_state_t_threadState_set},
-    { "extra",_wrap_input_callback_state_t_extra_get, _wrap_input_callback_state_t_extra_set},
-    { "funcargs",_wrap_input_callback_state_t_funcargs_get, _wrap_input_callback_state_t_funcargs_set},
+    { "function", _wrap_input_callback_state_t_function_get, _wrap_input_callback_state_t_function_set},
+    { "threadState", _wrap_input_callback_state_t_threadState_get, _wrap_input_callback_state_t_threadState_set},
+    { "extra", _wrap_input_callback_state_t_extra_get, _wrap_input_callback_state_t_extra_set},
+    { "funcargs", _wrap_input_callback_state_t_funcargs_get, _wrap_input_callback_state_t_funcargs_set},
     {0,0,0}
 };
 static swig_lua_class *swig_input_callback_state_t_bases[] = {0};
-swig_lua_class _wrap_class_input_callback_state_t = { "input_callback_state_t", &SWIGTYPE_p_input_callback_state,_wrap_new_input_callback_state_t, swig_delete_input_callback_state_t, swig_input_callback_state_t_methods, swig_input_callback_state_t_attributes, swig_input_callback_state_t_bases };
+static const char *swig_input_callback_state_t_base_names[] = {0};
+static swig_lua_class _wrap_class_input_callback_state_t = { "input_callback_state_t", &SWIGTYPE_p_input_callback_state,_wrap_new_input_callback_state_t, swig_delete_input_callback_state_t, swig_input_callback_state_t_methods, swig_input_callback_state_t_attributes, swig_input_callback_state_t_bases, swig_input_callback_state_t_base_names };
 
 static int _wrap_DTMF_digit_set(lua_State* L) {
   int SWIG_arg = -1;
   DTMF *arg1 = (DTMF *) 0 ;
   char arg2 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(DTMF *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_DTMF,0,1,"DTMF_digit_set");
-  arg2 = ((char*)lua_tostring(L, 2))[0];
+  SWIG_check_num_args("digit",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("digit",1,"DTMF *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("digit",2,"char");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_DTMF,0))){
+    SWIG_fail_ptr("DTMF_digit_set",1,SWIGTYPE_p_DTMF);
+  }
+  
+  arg2 = (lua_tostring(L, 2))[0];
   if (arg1) (arg1)->digit = arg2;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1910,13 +2219,20 @@ static int _wrap_DTMF_digit_get(lua_State* L) {
   DTMF *arg1 = (DTMF *) 0 ;
   char result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(DTMF *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_DTMF,0,1,"DTMF_digit_get");
+  SWIG_check_num_args("digit",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("digit",1,"DTMF *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_DTMF,0))){
+    SWIG_fail_ptr("DTMF_digit_get",1,SWIGTYPE_p_DTMF);
+  }
+  
   result = (char) ((arg1)->digit);
   SWIG_arg=0;
   lua_pushfstring(L,"%c",result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1927,21 +2243,30 @@ static int _wrap_DTMF_duration_set(lua_State* L) {
   int SWIG_arg = -1;
   DTMF *arg1 = (DTMF *) 0 ;
   uint32_t arg2 ;
+  uint32_t *argp2 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(DTMF *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_DTMF,0,1,"DTMF_duration_set");
-  {
-    uint32_t * argp;
-    if(SWIG_ConvertPtr(L,2,(void**)(&argp),SWIGTYPE_p_uint32_t,0)) SWIG_fail;
-    arg2 = *argp;
+  SWIG_check_num_args("duration",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("duration",1,"DTMF *");
+  if(!lua_isuserdata(L,2)) SWIG_fail_arg("duration",2,"uint32_t");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_DTMF,0))){
+    SWIG_fail_ptr("DTMF_duration_set",1,SWIGTYPE_p_DTMF);
   }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_uint32_t,0))){
+    SWIG_fail_ptr("DTMF_duration_set",2,SWIGTYPE_p_uint32_t);
+  }
+  arg2 = *argp2;
+  
   if (arg1) (arg1)->duration = arg2;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1953,17 +2278,23 @@ static int _wrap_DTMF_duration_get(lua_State* L) {
   DTMF *arg1 = (DTMF *) 0 ;
   uint32_t result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(DTMF *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_DTMF,0,1,"DTMF_duration_get");
+  SWIG_check_num_args("duration",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("duration",1,"DTMF *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_DTMF,0))){
+    SWIG_fail_ptr("DTMF_duration_get",1,SWIGTYPE_p_DTMF);
+  }
+  
   result =  ((arg1)->duration);
   SWIG_arg=0;
   {
-    uint32_t * resultptr;
-    resultptr = new uint32_t((uint32_t &) result);
+    uint32_t * resultptr = new uint32_t((uint32_t &) result);
     SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_uint32_t,1); SWIG_arg++;
   }
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -1975,22 +2306,25 @@ static int _wrap_new_DTMF(lua_State* L) {
   char arg1 ;
   uint32_t arg2 = (uint32_t) SWITCH_DEFAULT_DTMF_DURATION ;
   DTMF *result = 0 ;
+  uint32_t *argp2 ;
   
-  if(!lua_isstring(L,1)) SWIG_fail_arg(1);
-  if(lua_gettop(L)>=2 && !lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1 = ((char*)lua_tostring(L, 1))[0];
+  SWIG_check_num_args("DTMF",1,2)
+  if(!lua_isstring(L,1)) SWIG_fail_arg("DTMF",1,"char");
+  if(lua_gettop(L)>=2 && !lua_isuserdata(L,2)) SWIG_fail_arg("DTMF",2,"uint32_t");
+  arg1 = (lua_tostring(L, 1))[0];
   if(lua_gettop(L)>=2){
-    {
-      uint32_t * argp;
-      if(SWIG_ConvertPtr(L,2,(void**)(&argp),SWIGTYPE_p_uint32_t,0)) SWIG_fail;
-      arg2 = *argp;
+    if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_uint32_t,0))){
+      SWIG_fail_ptr("new_DTMF",2,SWIGTYPE_p_uint32_t);
     }
+    arg2 = *argp2;
   }
   result = (DTMF *)new DTMF(arg1,arg2);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_DTMF,1); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2001,14 +2335,21 @@ static int _wrap_delete_DTMF(lua_State* L) {
   int SWIG_arg = -1;
   DTMF *arg1 = (DTMF *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(DTMF *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_DTMF,0,1,"delete_DTMF");
+  SWIG_check_num_args("DTMF",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("DTMF",1,"DTMF *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_DTMF,SWIG_POINTER_DISOWN))){
+    SWIG_fail_ptr("delete_DTMF",1,SWIGTYPE_p_DTMF);
+  }
+  
   delete arg1;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2023,22 +2364,26 @@ static swig_lua_method swig_DTMF_methods[] = {
     {0,0}
 };
 static swig_lua_attribute swig_DTMF_attributes[] = {
-    { "digit",_wrap_DTMF_digit_get, _wrap_DTMF_digit_set},
-    { "duration",_wrap_DTMF_duration_get, _wrap_DTMF_duration_set},
+    { "digit", _wrap_DTMF_digit_get, _wrap_DTMF_digit_set},
+    { "duration", _wrap_DTMF_duration_get, _wrap_DTMF_duration_set},
     {0,0,0}
 };
 static swig_lua_class *swig_DTMF_bases[] = {0};
-swig_lua_class _wrap_class_DTMF = { "DTMF", &SWIGTYPE_p_DTMF,_wrap_new_DTMF, swig_delete_DTMF, swig_DTMF_methods, swig_DTMF_attributes, swig_DTMF_bases };
+static const char *swig_DTMF_base_names[] = {0};
+static swig_lua_class _wrap_class_DTMF = { "DTMF", &SWIGTYPE_p_DTMF,_wrap_new_DTMF, swig_delete_DTMF, swig_DTMF_methods, swig_DTMF_attributes, swig_DTMF_bases, swig_DTMF_base_names };
 
 static int _wrap_new_Stream__SWIG_0(lua_State* L) {
   int SWIG_arg = -1;
   Stream *result = 0 ;
   
+  SWIG_check_num_args("Stream",0,0)
   result = (Stream *)new Stream();
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_Stream,1); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2050,13 +2395,20 @@ static int _wrap_new_Stream__SWIG_1(lua_State* L) {
   switch_stream_handle_t *arg1 = (switch_stream_handle_t *) 0 ;
   Stream *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(switch_stream_handle_t *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_switch_stream_handle_t,0,1,"new_Stream");
+  SWIG_check_num_args("Stream",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Stream",1,"switch_stream_handle_t *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_switch_stream_handle_t,0))){
+    SWIG_fail_ptr("new_Stream",1,SWIGTYPE_p_switch_stream_handle_t);
+  }
+  
   result = (Stream *)new Stream(arg1);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_Stream,1); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2077,7 +2429,7 @@ static int _wrap_new_Stream(lua_State* L) {
     int _v;
     {
       void *ptr;
-      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_switch_stream_handle_t, 0)) {
+      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_switch_stream_handle_t, 0)) {
         _v = 0;
       } else {
         _v = 1;
@@ -2097,14 +2449,21 @@ static int _wrap_delete_Stream(lua_State* L) {
   int SWIG_arg = -1;
   Stream *arg1 = (Stream *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(Stream *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Stream,0,1,"delete_Stream");
+  SWIG_check_num_args("Stream",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Stream",1,"Stream *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Stream,SWIG_POINTER_DISOWN))){
+    SWIG_fail_ptr("delete_Stream",1,SWIGTYPE_p_Stream);
+  }
+  
   delete arg1;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2116,15 +2475,22 @@ static int _wrap_Stream_write(lua_State* L) {
   Stream *arg1 = (Stream *) 0 ;
   char *arg2 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(Stream *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Stream,0,1,"Stream_write");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("write",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("write",1,"Stream *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("write",2,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Stream,0))){
+    SWIG_fail_ptr("Stream_write",1,SWIGTYPE_p_Stream);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   (arg1)->write((char const *)arg2);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2136,13 +2502,20 @@ static int _wrap_Stream_get_data(lua_State* L) {
   Stream *arg1 = (Stream *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(Stream *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Stream,0,1,"Stream_get_data");
+  SWIG_check_num_args("get_data",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("get_data",1,"Stream *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Stream,0))){
+    SWIG_fail_ptr("Stream_get_data",1,SWIGTYPE_p_Stream);
+  }
+  
   result = (char *)(arg1)->get_data();
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2162,23 +2535,35 @@ static swig_lua_attribute swig_Stream_attributes[] = {
     {0,0,0}
 };
 static swig_lua_class *swig_Stream_bases[] = {0};
-swig_lua_class _wrap_class_Stream = { "Stream", &SWIGTYPE_p_Stream,_wrap_new_Stream, swig_delete_Stream, swig_Stream_methods, swig_Stream_attributes, swig_Stream_bases };
+static const char *swig_Stream_base_names[] = {0};
+static swig_lua_class _wrap_class_Stream = { "Stream", &SWIGTYPE_p_Stream,_wrap_new_Stream, swig_delete_Stream, swig_Stream_methods, swig_Stream_attributes, swig_Stream_bases, swig_Stream_base_names };
 
 static int _wrap_Event_event_set(lua_State* L) {
   int SWIG_arg = -1;
   Event *arg1 = (Event *) 0 ;
   switch_event_t *arg2 = (switch_event_t *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(Event *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Event,0,1,"Event_event_set");
-  arg2=(switch_event_t *)SWIG_MustGetPtr(L,2,SWIGTYPE_p_switch_event_t,0,2,"Event_event_set");
+  SWIG_check_num_args("event",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("event",1,"Event *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("event",2,"switch_event_t *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
+    SWIG_fail_ptr("Event_event_set",1,SWIGTYPE_p_Event);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_switch_event_t,SWIG_POINTER_DISOWN))){
+    SWIG_fail_ptr("Event_event_set",2,SWIGTYPE_p_switch_event_t);
+  }
+  
   if (arg1) (arg1)->event = arg2;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2190,13 +2575,20 @@ static int _wrap_Event_event_get(lua_State* L) {
   Event *arg1 = (Event *) 0 ;
   switch_event_t *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(Event *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Event,0,1,"Event_event_get");
+  SWIG_check_num_args("event",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("event",1,"Event *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
+    SWIG_fail_ptr("Event_event_get",1,SWIGTYPE_p_Event);
+  }
+  
   result = (switch_event_t *) ((arg1)->event);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_switch_event_t,0); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2208,15 +2600,20 @@ static int _wrap_Event_serialized_string_set(lua_State* L) {
   Event *arg1 = (Event *) 0 ;
   char *arg2 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(Event *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Event,0,1,"Event_serialized_string_set");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("serialized_string",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("serialized_string",1,"Event *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("serialized_string",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
+    SWIG_fail_ptr("Event_serialized_string_set",1,SWIGTYPE_p_Event);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   {
     if (arg1->serialized_string) delete [] arg1->serialized_string;
     if (arg2) {
-      arg1->serialized_string = (char *) (new char[strlen(arg2)+1]);
-      strcpy((char *) arg1->serialized_string,arg2);
+      arg1->serialized_string = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->serialized_string, (const char *)arg2);
     } else {
       arg1->serialized_string = 0;
     }
@@ -2225,6 +2622,8 @@ static int _wrap_Event_serialized_string_set(lua_State* L) {
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2236,13 +2635,20 @@ static int _wrap_Event_serialized_string_get(lua_State* L) {
   Event *arg1 = (Event *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(Event *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Event,0,1,"Event_serialized_string_get");
+  SWIG_check_num_args("serialized_string",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("serialized_string",1,"Event *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
+    SWIG_fail_ptr("Event_serialized_string_get",1,SWIGTYPE_p_Event);
+  }
+  
   result = (char *) ((arg1)->serialized_string);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2254,9 +2660,14 @@ static int _wrap_Event_mine_set(lua_State* L) {
   Event *arg1 = (Event *) 0 ;
   int arg2 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isnumber(L,2)) SWIG_fail_arg(2);
-  arg1=(Event *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Event,0,1,"Event_mine_set");
+  SWIG_check_num_args("mine",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("mine",1,"Event *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("mine",2,"int");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
+    SWIG_fail_ptr("Event_mine_set",1,SWIGTYPE_p_Event);
+  }
+  
   arg2 = (int)lua_tonumber(L, 2);
   if (arg1) (arg1)->mine = arg2;
   
@@ -2264,6 +2675,8 @@ static int _wrap_Event_mine_set(lua_State* L) {
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2275,13 +2688,20 @@ static int _wrap_Event_mine_get(lua_State* L) {
   Event *arg1 = (Event *) 0 ;
   int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(Event *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Event,0,1,"Event_mine_get");
+  SWIG_check_num_args("mine",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("mine",1,"Event *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
+    SWIG_fail_ptr("Event_mine_get",1,SWIGTYPE_p_Event);
+  }
+  
   result = (int) ((arg1)->mine);
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2294,17 +2714,20 @@ static int _wrap_new_Event__SWIG_0(lua_State* L) {
   char *arg2 = (char *) NULL ;
   Event *result = 0 ;
   
-  if(!lua_isstring(L,1)) SWIG_fail_arg(1);
-  if(lua_gettop(L)>=2 && !lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1 = (char*)lua_tostring(L, 1);
+  SWIG_check_num_args("Event",1,2)
+  if(!lua_isstring(L,1)) SWIG_fail_arg("Event",1,"char const *");
+  if(lua_gettop(L)>=2 && !lua_isstring(L,2)) SWIG_fail_arg("Event",2,"char const *");
+  arg1 = (char *)lua_tostring(L, 1);
   if(lua_gettop(L)>=2){
-    arg2 = (char*)lua_tostring(L, 2);
+    arg2 = (char *)lua_tostring(L, 2);
   }
   result = (Event *)new Event((char const *)arg1,(char const *)arg2);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_Event,1); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2317,9 +2740,14 @@ static int _wrap_new_Event__SWIG_1(lua_State* L) {
   int arg2 = (int) 0 ;
   Event *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(lua_gettop(L)>=2 && !lua_isnumber(L,2)) SWIG_fail_arg(2);
-  arg1=(switch_event_t *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_switch_event_t,0,1,"new_Event");
+  SWIG_check_num_args("Event",1,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Event",1,"switch_event_t *");
+  if(lua_gettop(L)>=2 && !lua_isnumber(L,2)) SWIG_fail_arg("Event",2,"int");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_switch_event_t,0))){
+    SWIG_fail_ptr("new_Event",1,SWIGTYPE_p_switch_event_t);
+  }
+  
   if(lua_gettop(L)>=2){
     arg2 = (int)lua_tonumber(L, 2);
   }
@@ -2328,6 +2756,8 @@ static int _wrap_new_Event__SWIG_1(lua_State* L) {
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_Event,1); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2345,7 +2775,7 @@ static int _wrap_new_Event(lua_State* L) {
     int _v;
     {
       void *ptr;
-      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_switch_event_t, 0)) {
+      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_switch_event_t, 0)) {
         _v = 0;
       } else {
         _v = 1;
@@ -2390,14 +2820,21 @@ static int _wrap_delete_Event(lua_State* L) {
   int SWIG_arg = -1;
   Event *arg1 = (Event *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(Event *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Event,0,1,"delete_Event");
+  SWIG_check_num_args("Event",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Event",1,"Event *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,SWIG_POINTER_DISOWN))){
+    SWIG_fail_ptr("delete_Event",1,SWIGTYPE_p_Event);
+  }
+  
   delete arg1;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2410,17 +2847,24 @@ static int _wrap_Event_serialize(lua_State* L) {
   char *arg2 = (char *) NULL ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(lua_gettop(L)>=2 && !lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(Event *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Event,0,1,"Event_serialize");
+  SWIG_check_num_args("serialize",1,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("serialize",1,"Event *");
+  if(lua_gettop(L)>=2 && !lua_isstring(L,2)) SWIG_fail_arg("serialize",2,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
+    SWIG_fail_ptr("Event_serialize",1,SWIGTYPE_p_Event);
+  }
+  
   if(lua_gettop(L)>=2){
-    arg2 = (char*)lua_tostring(L, 2);
+    arg2 = (char *)lua_tostring(L, 2);
   }
   result = (char *)(arg1)->serialize((char const *)arg2);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2432,22 +2876,29 @@ static int _wrap_Event_setPriority(lua_State* L) {
   Event *arg1 = (Event *) 0 ;
   switch_priority_t arg2 = (switch_priority_t) SWITCH_PRIORITY_NORMAL ;
   bool result;
+  switch_priority_t *argp2 ;
+  
+  SWIG_check_num_args("setPriority",1,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("setPriority",1,"Event *");
+  if(lua_gettop(L)>=2 && !lua_isuserdata(L,2)) SWIG_fail_arg("setPriority",2,"switch_priority_t");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
+    SWIG_fail_ptr("Event_setPriority",1,SWIGTYPE_p_Event);
+  }
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(lua_gettop(L)>=2 && !lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(Event *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Event,0,1,"Event_setPriority");
   if(lua_gettop(L)>=2){
-    {
-      switch_priority_t * argp;
-      if(SWIG_ConvertPtr(L,2,(void**)(&argp),SWIGTYPE_p_switch_priority_t,0)) SWIG_fail;
-      arg2 = *argp;
+    if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_switch_priority_t,0))){
+      SWIG_fail_ptr("Event_setPriority",2,SWIGTYPE_p_switch_priority_t);
     }
+    arg2 = *argp2;
   }
   result = (bool)(arg1)->setPriority(arg2);
   SWIG_arg=0;
-  lua_pushboolean(L,(int)result); SWIG_arg++;
+  lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2460,15 +2911,22 @@ static int _wrap_Event_getHeader(lua_State* L) {
   char *arg2 = (char *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(Event *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Event,0,1,"Event_getHeader");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("getHeader",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("getHeader",1,"Event *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("getHeader",2,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
+    SWIG_fail_ptr("Event_getHeader",1,SWIGTYPE_p_Event);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   result = (char *)(arg1)->getHeader((char const *)arg2);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2480,13 +2938,20 @@ static int _wrap_Event_getBody(lua_State* L) {
   Event *arg1 = (Event *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(Event *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Event,0,1,"Event_getBody");
+  SWIG_check_num_args("getBody",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("getBody",1,"Event *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
+    SWIG_fail_ptr("Event_getBody",1,SWIGTYPE_p_Event);
+  }
+  
   result = (char *)(arg1)->getBody();
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2498,13 +2963,20 @@ static int _wrap_Event_getType(lua_State* L) {
   Event *arg1 = (Event *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(Event *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Event,0,1,"Event_getType");
+  SWIG_check_num_args("getType",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("getType",1,"Event *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
+    SWIG_fail_ptr("Event_getType",1,SWIGTYPE_p_Event);
+  }
+  
   result = (char *)(arg1)->getType();
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2517,15 +2989,22 @@ static int _wrap_Event_addBody(lua_State* L) {
   char *arg2 = (char *) 0 ;
   bool result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(Event *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Event,0,1,"Event_addBody");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("addBody",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("addBody",1,"Event *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("addBody",2,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
+    SWIG_fail_ptr("Event_addBody",1,SWIGTYPE_p_Event);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   result = (bool)(arg1)->addBody((char const *)arg2);
   SWIG_arg=0;
-  lua_pushboolean(L,(int)result); SWIG_arg++;
+  lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2539,17 +3018,24 @@ static int _wrap_Event_addHeader(lua_State* L) {
   char *arg3 = (char *) 0 ;
   bool result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(!lua_isstring(L,3)) SWIG_fail_arg(3);
-  arg1=(Event *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Event,0,1,"Event_addHeader");
-  arg2 = (char*)lua_tostring(L, 2);
-  arg3 = (char*)lua_tostring(L, 3);
+  SWIG_check_num_args("addHeader",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("addHeader",1,"Event *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("addHeader",2,"char const *");
+  if(!lua_isstring(L,3)) SWIG_fail_arg("addHeader",3,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
+    SWIG_fail_ptr("Event_addHeader",1,SWIGTYPE_p_Event);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
+  arg3 = (char *)lua_tostring(L, 3);
   result = (bool)(arg1)->addHeader((char const *)arg2,(char const *)arg3);
   SWIG_arg=0;
-  lua_pushboolean(L,(int)result); SWIG_arg++;
+  lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2562,15 +3048,22 @@ static int _wrap_Event_delHeader(lua_State* L) {
   char *arg2 = (char *) 0 ;
   bool result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(Event *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Event,0,1,"Event_delHeader");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("delHeader",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("delHeader",1,"Event *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("delHeader",2,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
+    SWIG_fail_ptr("Event_delHeader",1,SWIGTYPE_p_Event);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   result = (bool)(arg1)->delHeader((char const *)arg2);
   SWIG_arg=0;
-  lua_pushboolean(L,(int)result); SWIG_arg++;
+  lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2582,13 +3075,20 @@ static int _wrap_Event_fire(lua_State* L) {
   Event *arg1 = (Event *) 0 ;
   bool result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(Event *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_Event,0,1,"Event_fire");
+  SWIG_check_num_args("fire",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("fire",1,"Event *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Event,0))){
+    SWIG_fail_ptr("Event_fire",1,SWIGTYPE_p_Event);
+  }
+  
   result = (bool)(arg1)->fire();
   SWIG_arg=0;
-  lua_pushboolean(L,(int)result); SWIG_arg++;
+  lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2612,29 +3112,41 @@ static swig_lua_method swig_Event_methods[] = {
     {0,0}
 };
 static swig_lua_attribute swig_Event_attributes[] = {
-    { "event",_wrap_Event_event_get, _wrap_Event_event_set},
-    { "serialized_string",_wrap_Event_serialized_string_get, _wrap_Event_serialized_string_set},
-    { "mine",_wrap_Event_mine_get, _wrap_Event_mine_set},
+    { "event", _wrap_Event_event_get, _wrap_Event_event_set},
+    { "serialized_string", _wrap_Event_serialized_string_get, _wrap_Event_serialized_string_set},
+    { "mine", _wrap_Event_mine_get, _wrap_Event_mine_set},
     {0,0,0}
 };
 static swig_lua_class *swig_Event_bases[] = {0};
-swig_lua_class _wrap_class_Event = { "Event", &SWIGTYPE_p_Event,_wrap_new_Event, swig_delete_Event, swig_Event_methods, swig_Event_attributes, swig_Event_bases };
+static const char *swig_Event_base_names[] = {0};
+static swig_lua_class _wrap_class_Event = { "Event", &SWIGTYPE_p_Event,_wrap_new_Event, swig_delete_Event, swig_Event_methods, swig_Event_attributes, swig_Event_bases, swig_Event_base_names };
 
 static int _wrap_EventConsumer_events_set(lua_State* L) {
   int SWIG_arg = -1;
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   switch_queue_t *arg2 = (switch_queue_t *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(EventConsumer *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_EventConsumer,0,1,"EventConsumer_events_set");
-  arg2=(switch_queue_t *)SWIG_MustGetPtr(L,2,SWIGTYPE_p_switch_queue_t,0,2,"EventConsumer_events_set");
+  SWIG_check_num_args("events",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("events",1,"EventConsumer *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("events",2,"switch_queue_t *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
+    SWIG_fail_ptr("EventConsumer_events_set",1,SWIGTYPE_p_EventConsumer);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_switch_queue_t,SWIG_POINTER_DISOWN))){
+    SWIG_fail_ptr("EventConsumer_events_set",2,SWIGTYPE_p_switch_queue_t);
+  }
+  
   if (arg1) (arg1)->events = arg2;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2646,13 +3158,20 @@ static int _wrap_EventConsumer_events_get(lua_State* L) {
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   switch_queue_t *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(EventConsumer *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_EventConsumer,0,1,"EventConsumer_events_get");
+  SWIG_check_num_args("events",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("events",1,"EventConsumer *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
+    SWIG_fail_ptr("EventConsumer_events_get",1,SWIGTYPE_p_EventConsumer);
+  }
+  
   result = (switch_queue_t *) ((arg1)->events);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_switch_queue_t,0); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2663,21 +3182,30 @@ static int _wrap_EventConsumer_e_event_id_set(lua_State* L) {
   int SWIG_arg = -1;
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   switch_event_types_t arg2 ;
+  switch_event_types_t *argp2 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(EventConsumer *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_EventConsumer,0,1,"EventConsumer_e_event_id_set");
-  {
-    switch_event_types_t * argp;
-    if(SWIG_ConvertPtr(L,2,(void**)(&argp),SWIGTYPE_p_switch_event_types_t,0)) SWIG_fail;
-    arg2 = *argp;
+  SWIG_check_num_args("e_event_id",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("e_event_id",1,"EventConsumer *");
+  if(!lua_isuserdata(L,2)) SWIG_fail_arg("e_event_id",2,"switch_event_types_t");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
+    SWIG_fail_ptr("EventConsumer_e_event_id_set",1,SWIGTYPE_p_EventConsumer);
   }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_switch_event_types_t,0))){
+    SWIG_fail_ptr("EventConsumer_e_event_id_set",2,SWIGTYPE_p_switch_event_types_t);
+  }
+  arg2 = *argp2;
+  
   if (arg1) (arg1)->e_event_id = arg2;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2689,17 +3217,23 @@ static int _wrap_EventConsumer_e_event_id_get(lua_State* L) {
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   switch_event_types_t result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(EventConsumer *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_EventConsumer,0,1,"EventConsumer_e_event_id_get");
+  SWIG_check_num_args("e_event_id",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("e_event_id",1,"EventConsumer *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
+    SWIG_fail_ptr("EventConsumer_e_event_id_get",1,SWIGTYPE_p_EventConsumer);
+  }
+  
   result =  ((arg1)->e_event_id);
   SWIG_arg=0;
   {
-    switch_event_types_t * resultptr;
-    resultptr = new switch_event_types_t((switch_event_types_t &) result);
+    switch_event_types_t * resultptr = new switch_event_types_t((switch_event_types_t &) result);
     SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_switch_event_types_t,1); SWIG_arg++;
   }
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2711,15 +3245,20 @@ static int _wrap_EventConsumer_e_callback_set(lua_State* L) {
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   char *arg2 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(EventConsumer *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_EventConsumer,0,1,"EventConsumer_e_callback_set");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("e_callback",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("e_callback",1,"EventConsumer *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("e_callback",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
+    SWIG_fail_ptr("EventConsumer_e_callback_set",1,SWIGTYPE_p_EventConsumer);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   {
     if (arg1->e_callback) delete [] arg1->e_callback;
     if (arg2) {
-      arg1->e_callback = (char *) (new char[strlen(arg2)+1]);
-      strcpy((char *) arg1->e_callback,arg2);
+      arg1->e_callback = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->e_callback, (const char *)arg2);
     } else {
       arg1->e_callback = 0;
     }
@@ -2728,6 +3267,8 @@ static int _wrap_EventConsumer_e_callback_set(lua_State* L) {
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2739,13 +3280,20 @@ static int _wrap_EventConsumer_e_callback_get(lua_State* L) {
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(EventConsumer *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_EventConsumer,0,1,"EventConsumer_e_callback_get");
+  SWIG_check_num_args("e_callback",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("e_callback",1,"EventConsumer *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
+    SWIG_fail_ptr("EventConsumer_e_callback_get",1,SWIGTYPE_p_EventConsumer);
+  }
+  
   result = (char *) ((arg1)->e_callback);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2757,15 +3305,20 @@ static int _wrap_EventConsumer_e_subclass_name_set(lua_State* L) {
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   char *arg2 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(EventConsumer *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_EventConsumer,0,1,"EventConsumer_e_subclass_name_set");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("e_subclass_name",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("e_subclass_name",1,"EventConsumer *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("e_subclass_name",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
+    SWIG_fail_ptr("EventConsumer_e_subclass_name_set",1,SWIGTYPE_p_EventConsumer);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   {
     if (arg1->e_subclass_name) delete [] arg1->e_subclass_name;
     if (arg2) {
-      arg1->e_subclass_name = (char *) (new char[strlen(arg2)+1]);
-      strcpy((char *) arg1->e_subclass_name,arg2);
+      arg1->e_subclass_name = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->e_subclass_name, (const char *)arg2);
     } else {
       arg1->e_subclass_name = 0;
     }
@@ -2774,6 +3327,8 @@ static int _wrap_EventConsumer_e_subclass_name_set(lua_State* L) {
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2785,13 +3340,20 @@ static int _wrap_EventConsumer_e_subclass_name_get(lua_State* L) {
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(EventConsumer *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_EventConsumer,0,1,"EventConsumer_e_subclass_name_get");
+  SWIG_check_num_args("e_subclass_name",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("e_subclass_name",1,"EventConsumer *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
+    SWIG_fail_ptr("EventConsumer_e_subclass_name_get",1,SWIGTYPE_p_EventConsumer);
+  }
+  
   result = (char *) ((arg1)->e_subclass_name);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2803,15 +3365,20 @@ static int _wrap_EventConsumer_e_cb_arg_set(lua_State* L) {
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   char *arg2 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(EventConsumer *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_EventConsumer,0,1,"EventConsumer_e_cb_arg_set");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("e_cb_arg",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("e_cb_arg",1,"EventConsumer *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("e_cb_arg",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
+    SWIG_fail_ptr("EventConsumer_e_cb_arg_set",1,SWIGTYPE_p_EventConsumer);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   {
     if (arg1->e_cb_arg) delete [] arg1->e_cb_arg;
     if (arg2) {
-      arg1->e_cb_arg = (char *) (new char[strlen(arg2)+1]);
-      strcpy((char *) arg1->e_cb_arg,arg2);
+      arg1->e_cb_arg = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->e_cb_arg, (const char *)arg2);
     } else {
       arg1->e_cb_arg = 0;
     }
@@ -2820,6 +3387,8 @@ static int _wrap_EventConsumer_e_cb_arg_set(lua_State* L) {
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2831,13 +3400,20 @@ static int _wrap_EventConsumer_e_cb_arg_get(lua_State* L) {
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(EventConsumer *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_EventConsumer,0,1,"EventConsumer_e_cb_arg_get");
+  SWIG_check_num_args("e_cb_arg",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("e_cb_arg",1,"EventConsumer *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
+    SWIG_fail_ptr("EventConsumer_e_cb_arg_get",1,SWIGTYPE_p_EventConsumer);
+  }
+  
   result = (char *) ((arg1)->e_cb_arg);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2849,10 +3425,19 @@ static int _wrap_EventConsumer_enodes_set(lua_State* L) {
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   switch_event_node_t **arg2 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(EventConsumer *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_EventConsumer,0,1,"EventConsumer_enodes_set");
-  arg2=(switch_event_node_t **)SWIG_MustGetPtr(L,2,SWIGTYPE_p_p_switch_event_node_t,0,2,"EventConsumer_enodes_set");
+  SWIG_check_num_args("enodes",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("enodes",1,"EventConsumer *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("enodes",2,"switch_event_node_t *[SWITCH_EVENT_ALL+1]");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
+    SWIG_fail_ptr("EventConsumer_enodes_set",1,SWIGTYPE_p_EventConsumer);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_p_switch_event_node_t,0))){
+    SWIG_fail_ptr("EventConsumer_enodes_set",2,SWIGTYPE_p_p_switch_event_node_t);
+  }
+  
   {
     size_t ii;
     switch_event_node_t * *b = (switch_event_node_t * *) arg1->enodes;
@@ -2862,6 +3447,8 @@ static int _wrap_EventConsumer_enodes_set(lua_State* L) {
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2873,13 +3460,20 @@ static int _wrap_EventConsumer_enodes_get(lua_State* L) {
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   switch_event_node_t **result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(EventConsumer *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_EventConsumer,0,1,"EventConsumer_enodes_get");
+  SWIG_check_num_args("enodes",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("enodes",1,"EventConsumer *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
+    SWIG_fail_ptr("EventConsumer_enodes_get",1,SWIGTYPE_p_EventConsumer);
+  }
+  
   result = (switch_event_node_t **)(switch_event_node_t **) ((arg1)->enodes);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_p_switch_event_node_t,0); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2890,21 +3484,30 @@ static int _wrap_EventConsumer_node_index_set(lua_State* L) {
   int SWIG_arg = -1;
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   uint32_t arg2 ;
+  uint32_t *argp2 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(EventConsumer *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_EventConsumer,0,1,"EventConsumer_node_index_set");
-  {
-    uint32_t * argp;
-    if(SWIG_ConvertPtr(L,2,(void**)(&argp),SWIGTYPE_p_uint32_t,0)) SWIG_fail;
-    arg2 = *argp;
+  SWIG_check_num_args("node_index",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("node_index",1,"EventConsumer *");
+  if(!lua_isuserdata(L,2)) SWIG_fail_arg("node_index",2,"uint32_t");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
+    SWIG_fail_ptr("EventConsumer_node_index_set",1,SWIGTYPE_p_EventConsumer);
   }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_uint32_t,0))){
+    SWIG_fail_ptr("EventConsumer_node_index_set",2,SWIGTYPE_p_uint32_t);
+  }
+  arg2 = *argp2;
+  
   if (arg1) (arg1)->node_index = arg2;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2916,17 +3519,23 @@ static int _wrap_EventConsumer_node_index_get(lua_State* L) {
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   uint32_t result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(EventConsumer *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_EventConsumer,0,1,"EventConsumer_node_index_get");
+  SWIG_check_num_args("node_index",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("node_index",1,"EventConsumer *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
+    SWIG_fail_ptr("EventConsumer_node_index_get",1,SWIGTYPE_p_EventConsumer);
+  }
+  
   result =  ((arg1)->node_index);
   SWIG_arg=0;
   {
-    uint32_t * resultptr;
-    resultptr = new uint32_t((uint32_t &) result);
+    uint32_t * resultptr = new uint32_t((uint32_t &) result);
     SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_uint32_t,1); SWIG_arg++;
   }
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2939,19 +3548,22 @@ static int _wrap_new_EventConsumer(lua_State* L) {
   char *arg2 = (char *) "" ;
   EventConsumer *result = 0 ;
   
-  if(lua_gettop(L)>=1 && !lua_isstring(L,1)) SWIG_fail_arg(1);
-  if(lua_gettop(L)>=2 && !lua_isstring(L,2)) SWIG_fail_arg(2);
+  SWIG_check_num_args("EventConsumer",0,2)
+  if(lua_gettop(L)>=1 && !lua_isstring(L,1)) SWIG_fail_arg("EventConsumer",1,"char const *");
+  if(lua_gettop(L)>=2 && !lua_isstring(L,2)) SWIG_fail_arg("EventConsumer",2,"char const *");
   if(lua_gettop(L)>=1){
-    arg1 = (char*)lua_tostring(L, 1);
+    arg1 = (char *)lua_tostring(L, 1);
   }
   if(lua_gettop(L)>=2){
-    arg2 = (char*)lua_tostring(L, 2);
+    arg2 = (char *)lua_tostring(L, 2);
   }
   result = (EventConsumer *)new EventConsumer((char const *)arg1,(char const *)arg2);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_EventConsumer,1); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2962,14 +3574,21 @@ static int _wrap_delete_EventConsumer(lua_State* L) {
   int SWIG_arg = -1;
   EventConsumer *arg1 = (EventConsumer *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(EventConsumer *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_EventConsumer,0,1,"delete_EventConsumer");
+  SWIG_check_num_args("EventConsumer",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("EventConsumer",1,"EventConsumer *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,SWIG_POINTER_DISOWN))){
+    SWIG_fail_ptr("delete_EventConsumer",1,SWIGTYPE_p_EventConsumer);
+  }
+  
   delete arg1;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -2983,19 +3602,26 @@ static int _wrap_EventConsumer_bind(lua_State* L) {
   char *arg3 = (char *) "" ;
   int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(lua_gettop(L)>=3 && !lua_isstring(L,3)) SWIG_fail_arg(3);
-  arg1=(EventConsumer *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_EventConsumer,0,1,"EventConsumer_bind");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("bind",2,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("bind",1,"EventConsumer *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("bind",2,"char const *");
+  if(lua_gettop(L)>=3 && !lua_isstring(L,3)) SWIG_fail_arg("bind",3,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
+    SWIG_fail_ptr("EventConsumer_bind",1,SWIGTYPE_p_EventConsumer);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   if(lua_gettop(L)>=3){
-    arg3 = (char*)lua_tostring(L, 3);
+    arg3 = (char *)lua_tostring(L, 3);
   }
   result = (int)(arg1)->bind((char const *)arg2,(char const *)arg3);
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3008,9 +3634,14 @@ static int _wrap_EventConsumer_pop(lua_State* L) {
   int arg2 = (int) 0 ;
   Event *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(lua_gettop(L)>=2 && !lua_isnumber(L,2)) SWIG_fail_arg(2);
-  arg1=(EventConsumer *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_EventConsumer,0,1,"EventConsumer_pop");
+  SWIG_check_num_args("pop",1,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("pop",1,"EventConsumer *");
+  if(lua_gettop(L)>=2 && !lua_isnumber(L,2)) SWIG_fail_arg("pop",2,"int");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_EventConsumer,0))){
+    SWIG_fail_ptr("EventConsumer_pop",1,SWIGTYPE_p_EventConsumer);
+  }
+  
   if(lua_gettop(L)>=2){
     arg2 = (int)lua_tonumber(L, 2);
   }
@@ -3019,6 +3650,8 @@ static int _wrap_EventConsumer_pop(lua_State* L) {
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_Event,1); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3035,30 +3668,38 @@ static swig_lua_method swig_EventConsumer_methods[] = {
     {0,0}
 };
 static swig_lua_attribute swig_EventConsumer_attributes[] = {
-    { "events",_wrap_EventConsumer_events_get, _wrap_EventConsumer_events_set},
-    { "e_event_id",_wrap_EventConsumer_e_event_id_get, _wrap_EventConsumer_e_event_id_set},
-    { "e_callback",_wrap_EventConsumer_e_callback_get, _wrap_EventConsumer_e_callback_set},
-    { "e_subclass_name",_wrap_EventConsumer_e_subclass_name_get, _wrap_EventConsumer_e_subclass_name_set},
-    { "e_cb_arg",_wrap_EventConsumer_e_cb_arg_get, _wrap_EventConsumer_e_cb_arg_set},
-    { "enodes",_wrap_EventConsumer_enodes_get, _wrap_EventConsumer_enodes_set},
-    { "node_index",_wrap_EventConsumer_node_index_get, _wrap_EventConsumer_node_index_set},
+    { "events", _wrap_EventConsumer_events_get, _wrap_EventConsumer_events_set},
+    { "e_event_id", _wrap_EventConsumer_e_event_id_get, _wrap_EventConsumer_e_event_id_set},
+    { "e_callback", _wrap_EventConsumer_e_callback_get, _wrap_EventConsumer_e_callback_set},
+    { "e_subclass_name", _wrap_EventConsumer_e_subclass_name_get, _wrap_EventConsumer_e_subclass_name_set},
+    { "e_cb_arg", _wrap_EventConsumer_e_cb_arg_get, _wrap_EventConsumer_e_cb_arg_set},
+    { "enodes", _wrap_EventConsumer_enodes_get, _wrap_EventConsumer_enodes_set},
+    { "node_index", _wrap_EventConsumer_node_index_get, _wrap_EventConsumer_node_index_set},
     {0,0,0}
 };
 static swig_lua_class *swig_EventConsumer_bases[] = {0};
-swig_lua_class _wrap_class_EventConsumer = { "EventConsumer", &SWIGTYPE_p_EventConsumer,_wrap_new_EventConsumer, swig_delete_EventConsumer, swig_EventConsumer_methods, swig_EventConsumer_attributes, swig_EventConsumer_bases };
+static const char *swig_EventConsumer_base_names[] = {0};
+static swig_lua_class _wrap_class_EventConsumer = { "EventConsumer", &SWIGTYPE_p_EventConsumer,_wrap_new_EventConsumer, swig_delete_EventConsumer, swig_EventConsumer_methods, swig_EventConsumer_attributes, swig_EventConsumer_bases, swig_EventConsumer_base_names };
 
 static int _wrap_delete_CoreSession(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"delete_CoreSession");
+  SWIG_check_num_args("CoreSession",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("CoreSession",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,SWIG_POINTER_DISOWN))){
+    SWIG_fail_ptr("delete_CoreSession",1,SWIGTYPE_p_CoreSession);
+  }
+  
   delete arg1;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3070,16 +3711,27 @@ static int _wrap_CoreSession_session_set(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   switch_core_session_t *arg2 = (switch_core_session_t *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_session_set");
-  arg2=(switch_core_session_t *)SWIG_MustGetPtr(L,2,SWIGTYPE_p_switch_core_session_t,0,2,"CoreSession_session_set");
+  SWIG_check_num_args("session",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("session",1,"CoreSession *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("session",2,"switch_core_session_t *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_session_set",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_switch_core_session_t,SWIG_POINTER_DISOWN))){
+    SWIG_fail_ptr("CoreSession_session_set",2,SWIGTYPE_p_switch_core_session_t);
+  }
+  
   if (arg1) (arg1)->session = arg2;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3091,13 +3743,20 @@ static int _wrap_CoreSession_session_get(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   switch_core_session_t *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_session_get");
+  SWIG_check_num_args("session",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("session",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_session_get",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (switch_core_session_t *) ((arg1)->session);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_switch_core_session_t,0); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3109,16 +3768,27 @@ static int _wrap_CoreSession_channel_set(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   switch_channel_t *arg2 = (switch_channel_t *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_channel_set");
-  arg2=(switch_channel_t *)SWIG_MustGetPtr(L,2,SWIGTYPE_p_switch_channel_t,0,2,"CoreSession_channel_set");
+  SWIG_check_num_args("channel",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("channel",1,"CoreSession *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("channel",2,"switch_channel_t *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_channel_set",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_switch_channel_t,SWIG_POINTER_DISOWN))){
+    SWIG_fail_ptr("CoreSession_channel_set",2,SWIGTYPE_p_switch_channel_t);
+  }
+  
   if (arg1) (arg1)->channel = arg2;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3130,13 +3800,20 @@ static int _wrap_CoreSession_channel_get(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   switch_channel_t *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_channel_get");
+  SWIG_check_num_args("channel",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("channel",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_channel_get",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (switch_channel_t *) ((arg1)->channel);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_switch_channel_t,0); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3148,9 +3825,14 @@ static int _wrap_CoreSession_flags_set(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   unsigned int arg2 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isnumber(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_flags_set");
+  SWIG_check_num_args("flags",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("flags",1,"CoreSession *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("flags",2,"unsigned int");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_flags_set",1,SWIGTYPE_p_CoreSession);
+  }
+  
   arg2 = (unsigned int)lua_tonumber(L, 2);
   if (arg1) (arg1)->flags = arg2;
   
@@ -3158,6 +3840,8 @@ static int _wrap_CoreSession_flags_set(lua_State* L) {
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3169,13 +3853,20 @@ static int _wrap_CoreSession_flags_get(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   unsigned int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_flags_get");
+  SWIG_check_num_args("flags",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("flags",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_flags_get",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (unsigned int) ((arg1)->flags);
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3187,9 +3878,14 @@ static int _wrap_CoreSession_allocated_set(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   int arg2 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isnumber(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_allocated_set");
+  SWIG_check_num_args("allocated",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("allocated",1,"CoreSession *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("allocated",2,"int");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_allocated_set",1,SWIGTYPE_p_CoreSession);
+  }
+  
   arg2 = (int)lua_tonumber(L, 2);
   if (arg1) (arg1)->allocated = arg2;
   
@@ -3197,6 +3893,8 @@ static int _wrap_CoreSession_allocated_set(lua_State* L) {
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3208,13 +3906,20 @@ static int _wrap_CoreSession_allocated_get(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_allocated_get");
+  SWIG_check_num_args("allocated",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("allocated",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_allocated_get",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (int) ((arg1)->allocated);
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3226,16 +3931,27 @@ static int _wrap_CoreSession_cb_state_set(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   input_callback_state *arg2 = (input_callback_state *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_cb_state_set");
-  arg2=(input_callback_state *)SWIG_MustGetPtr(L,2,SWIGTYPE_p_input_callback_state,0,2,"CoreSession_cb_state_set");
+  SWIG_check_num_args("cb_state",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("cb_state",1,"CoreSession *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("cb_state",2,"input_callback_state *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_cb_state_set",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_input_callback_state,0))){
+    SWIG_fail_ptr("CoreSession_cb_state_set",2,SWIGTYPE_p_input_callback_state);
+  }
+  
   if (arg1) (arg1)->cb_state = *arg2;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3247,13 +3963,20 @@ static int _wrap_CoreSession_cb_state_get(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   input_callback_state *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_cb_state_get");
+  SWIG_check_num_args("cb_state",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("cb_state",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_cb_state_get",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (input_callback_state *)& ((arg1)->cb_state);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_input_callback_state,0); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3264,21 +3987,30 @@ static int _wrap_CoreSession_hook_state_set(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
   switch_channel_state_t arg2 ;
+  switch_channel_state_t *argp2 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_hook_state_set");
-  {
-    switch_channel_state_t * argp;
-    if(SWIG_ConvertPtr(L,2,(void**)(&argp),SWIGTYPE_p_switch_channel_state_t,0)) SWIG_fail;
-    arg2 = *argp;
+  SWIG_check_num_args("hook_state",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("hook_state",1,"CoreSession *");
+  if(!lua_isuserdata(L,2)) SWIG_fail_arg("hook_state",2,"switch_channel_state_t");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_hook_state_set",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_switch_channel_state_t,0))){
+    SWIG_fail_ptr("CoreSession_hook_state_set",2,SWIGTYPE_p_switch_channel_state_t);
   }
+  arg2 = *argp2;
+  
   if (arg1) (arg1)->hook_state = arg2;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3290,17 +4022,23 @@ static int _wrap_CoreSession_hook_state_get(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   switch_channel_state_t result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_hook_state_get");
+  SWIG_check_num_args("hook_state",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("hook_state",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_hook_state_get",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result =  ((arg1)->hook_state);
   SWIG_arg=0;
   {
-    switch_channel_state_t * resultptr;
-    resultptr = new switch_channel_state_t((switch_channel_state_t &) result);
+    switch_channel_state_t * resultptr = new switch_channel_state_t((switch_channel_state_t &) result);
     SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_switch_channel_state_t,1); SWIG_arg++;
   }
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3311,21 +4049,30 @@ static int _wrap_CoreSession_cause_set(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
   switch_call_cause_t arg2 ;
+  switch_call_cause_t *argp2 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_cause_set");
-  {
-    switch_call_cause_t * argp;
-    if(SWIG_ConvertPtr(L,2,(void**)(&argp),SWIGTYPE_p_switch_call_cause_t,0)) SWIG_fail;
-    arg2 = *argp;
+  SWIG_check_num_args("cause",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("cause",1,"CoreSession *");
+  if(!lua_isuserdata(L,2)) SWIG_fail_arg("cause",2,"switch_call_cause_t");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_cause_set",1,SWIGTYPE_p_CoreSession);
   }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_switch_call_cause_t,0))){
+    SWIG_fail_ptr("CoreSession_cause_set",2,SWIGTYPE_p_switch_call_cause_t);
+  }
+  arg2 = *argp2;
+  
   if (arg1) (arg1)->cause = arg2;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3337,17 +4084,23 @@ static int _wrap_CoreSession_cause_get(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   switch_call_cause_t result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_cause_get");
+  SWIG_check_num_args("cause",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("cause",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_cause_get",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result =  ((arg1)->cause);
   SWIG_arg=0;
   {
-    switch_call_cause_t * resultptr;
-    resultptr = new switch_call_cause_t((switch_call_cause_t &) result);
+    switch_call_cause_t * resultptr = new switch_call_cause_t((switch_call_cause_t &) result);
     SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_switch_call_cause_t,1); SWIG_arg++;
   }
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3359,15 +4112,20 @@ static int _wrap_CoreSession_uuid_set(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_uuid_set");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("uuid",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("uuid",1,"CoreSession *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("uuid",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_uuid_set",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   {
     if (arg1->uuid) delete [] arg1->uuid;
     if (arg2) {
-      arg1->uuid = (char *) (new char[strlen(arg2)+1]);
-      strcpy((char *) arg1->uuid,arg2);
+      arg1->uuid = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->uuid, (const char *)arg2);
     } else {
       arg1->uuid = 0;
     }
@@ -3376,6 +4134,8 @@ static int _wrap_CoreSession_uuid_set(lua_State* L) {
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3387,13 +4147,20 @@ static int _wrap_CoreSession_uuid_get(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_uuid_get");
+  SWIG_check_num_args("uuid",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("uuid",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_uuid_get",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (char *) ((arg1)->uuid);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3405,15 +4172,20 @@ static int _wrap_CoreSession_tts_name_set(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_tts_name_set");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("tts_name",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("tts_name",1,"CoreSession *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("tts_name",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_tts_name_set",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   {
     if (arg1->tts_name) delete [] arg1->tts_name;
     if (arg2) {
-      arg1->tts_name = (char *) (new char[strlen(arg2)+1]);
-      strcpy((char *) arg1->tts_name,arg2);
+      arg1->tts_name = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->tts_name, (const char *)arg2);
     } else {
       arg1->tts_name = 0;
     }
@@ -3422,6 +4194,8 @@ static int _wrap_CoreSession_tts_name_set(lua_State* L) {
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3433,13 +4207,20 @@ static int _wrap_CoreSession_tts_name_get(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_tts_name_get");
+  SWIG_check_num_args("tts_name",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("tts_name",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_tts_name_get",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (char *) ((arg1)->tts_name);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3451,15 +4232,20 @@ static int _wrap_CoreSession_voice_name_set(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_voice_name_set");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("voice_name",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("voice_name",1,"CoreSession *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("voice_name",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_voice_name_set",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   {
     if (arg1->voice_name) delete [] arg1->voice_name;
     if (arg2) {
-      arg1->voice_name = (char *) (new char[strlen(arg2)+1]);
-      strcpy((char *) arg1->voice_name,arg2);
+      arg1->voice_name = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->voice_name, (const char *)arg2);
     } else {
       arg1->voice_name = 0;
     }
@@ -3468,6 +4254,8 @@ static int _wrap_CoreSession_voice_name_set(lua_State* L) {
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3479,13 +4267,20 @@ static int _wrap_CoreSession_voice_name_get(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_voice_name_get");
+  SWIG_check_num_args("voice_name",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("voice_name",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_voice_name_get",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (char *) ((arg1)->voice_name);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3497,13 +4292,20 @@ static int _wrap_CoreSession_answer(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_answer");
+  SWIG_check_num_args("answer",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("answer",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_answer",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (int)(arg1)->answer();
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3515,13 +4317,20 @@ static int _wrap_CoreSession_preAnswer(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_preAnswer");
+  SWIG_check_num_args("preAnswer",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("preAnswer",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_preAnswer",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (int)(arg1)->preAnswer();
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3533,17 +4342,24 @@ static int _wrap_CoreSession_hangup(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *arg2 = (char *) "normal_clearing" ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(lua_gettop(L)>=2 && !lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_hangup");
+  SWIG_check_num_args("hangup",1,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("hangup",1,"CoreSession *");
+  if(lua_gettop(L)>=2 && !lua_isstring(L,2)) SWIG_fail_arg("hangup",2,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_hangup",1,SWIGTYPE_p_CoreSession);
+  }
+  
   if(lua_gettop(L)>=2){
-    arg2 = (char*)lua_tostring(L, 2);
+    arg2 = (char *)lua_tostring(L, 2);
   }
   (arg1)->hangup((char const *)arg2);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3554,13 +4370,20 @@ static int _wrap_CoreSession_hangupState(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_hangupState");
+  SWIG_check_num_args("hangupState",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("hangupState",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_hangupState",1,SWIGTYPE_p_CoreSession);
+  }
+  
   (arg1)->hangupState();
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3573,17 +4396,24 @@ static int _wrap_CoreSession_setVariable(lua_State* L) {
   char *arg2 = (char *) 0 ;
   char *arg3 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(!lua_isstring(L,3)) SWIG_fail_arg(3);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_setVariable");
-  arg2 = (char*)lua_tostring(L, 2);
-  arg3 = (char*)lua_tostring(L, 3);
+  SWIG_check_num_args("setVariable",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("setVariable",1,"CoreSession *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("setVariable",2,"char *");
+  if(!lua_isstring(L,3)) SWIG_fail_arg("setVariable",3,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_setVariable",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
+  arg3 = (char *)lua_tostring(L, 3);
   (arg1)->setVariable(arg2,arg3);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3596,17 +4426,24 @@ static int _wrap_CoreSession_setPrivate(lua_State* L) {
   char *arg2 = (char *) 0 ;
   void *arg3 = (void *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(!lua_isuserdata(L,3)) SWIG_fail_arg(3);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_setPrivate");
-  arg2 = (char*)lua_tostring(L, 2);
-  arg3=((swig_lua_userdata*)(lua_touserdata(L,3)))->ptr;
+  SWIG_check_num_args("setPrivate",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("setPrivate",1,"CoreSession *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("setPrivate",2,"char *");
+  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("setPrivate",3,"void *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_setPrivate",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
+  arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"CoreSession_setPrivate");
   (arg1)->setPrivate(arg2,arg3);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3619,15 +4456,22 @@ static int _wrap_CoreSession_getPrivate(lua_State* L) {
   char *arg2 = (char *) 0 ;
   void *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_getPrivate");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("getPrivate",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("getPrivate",1,"CoreSession *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("getPrivate",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_getPrivate",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   result = (void *)(arg1)->getPrivate(arg2);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_void,0); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3640,15 +4484,22 @@ static int _wrap_CoreSession_getVariable(lua_State* L) {
   char *arg2 = (char *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_getVariable");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("getVariable",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("getVariable",1,"CoreSession *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("getVariable",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_getVariable",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   result = (char *)(arg1)->getVariable(arg2);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3661,19 +4512,25 @@ static int _wrap_CoreSession_process_callback_result(lua_State* L) {
   char *arg2 = (char *) 0 ;
   switch_status_t result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_process_callback_result");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("process_callback_result",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("process_callback_result",1,"CoreSession *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("process_callback_result",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_process_callback_result",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   result = (arg1)->process_callback_result(arg2);
   SWIG_arg=0;
   {
-    switch_status_t * resultptr;
-    resultptr = new switch_status_t((switch_status_t &) result);
+    switch_status_t * resultptr = new switch_status_t((switch_status_t &) result);
     SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_switch_status_t,1); SWIG_arg++;
   }
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3689,25 +4546,32 @@ static int _wrap_CoreSession_say(lua_State* L) {
   char *arg5 = (char *) 0 ;
   char *arg6 = (char *) NULL ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(!lua_isstring(L,3)) SWIG_fail_arg(3);
-  if(!lua_isstring(L,4)) SWIG_fail_arg(4);
-  if(!lua_isstring(L,5)) SWIG_fail_arg(5);
-  if(lua_gettop(L)>=6 && !lua_isstring(L,6)) SWIG_fail_arg(6);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_say");
-  arg2 = (char*)lua_tostring(L, 2);
-  arg3 = (char*)lua_tostring(L, 3);
-  arg4 = (char*)lua_tostring(L, 4);
-  arg5 = (char*)lua_tostring(L, 5);
+  SWIG_check_num_args("say",5,6)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("say",1,"CoreSession *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("say",2,"char const *");
+  if(!lua_isstring(L,3)) SWIG_fail_arg("say",3,"char const *");
+  if(!lua_isstring(L,4)) SWIG_fail_arg("say",4,"char const *");
+  if(!lua_isstring(L,5)) SWIG_fail_arg("say",5,"char const *");
+  if(lua_gettop(L)>=6 && !lua_isstring(L,6)) SWIG_fail_arg("say",6,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_say",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
+  arg3 = (char *)lua_tostring(L, 3);
+  arg4 = (char *)lua_tostring(L, 4);
+  arg5 = (char *)lua_tostring(L, 5);
   if(lua_gettop(L)>=6){
-    arg6 = (char*)lua_tostring(L, 6);
+    arg6 = (char *)lua_tostring(L, 6);
   }
   (arg1)->say((char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3721,23 +4585,30 @@ static int _wrap_CoreSession_sayPhrase(lua_State* L) {
   char *arg3 = (char *) "" ;
   char *arg4 = (char *) NULL ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(lua_gettop(L)>=3 && !lua_isstring(L,3)) SWIG_fail_arg(3);
-  if(lua_gettop(L)>=4 && !lua_isstring(L,4)) SWIG_fail_arg(4);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_sayPhrase");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("sayPhrase",2,4)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("sayPhrase",1,"CoreSession *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("sayPhrase",2,"char const *");
+  if(lua_gettop(L)>=3 && !lua_isstring(L,3)) SWIG_fail_arg("sayPhrase",3,"char const *");
+  if(lua_gettop(L)>=4 && !lua_isstring(L,4)) SWIG_fail_arg("sayPhrase",4,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_sayPhrase",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   if(lua_gettop(L)>=3){
-    arg3 = (char*)lua_tostring(L, 3);
+    arg3 = (char *)lua_tostring(L, 3);
   }
   if(lua_gettop(L)>=4){
-    arg4 = (char*)lua_tostring(L, 4);
+    arg4 = (char *)lua_tostring(L, 4);
   }
   (arg1)->sayPhrase((char const *)arg2,(char const *)arg3,(char const *)arg4);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3749,13 +4620,20 @@ static int _wrap_CoreSession_hangupCause(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_hangupCause");
+  SWIG_check_num_args("hangupCause",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("hangupCause",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_hangupCause",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (char *)(arg1)->hangupCause();
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3767,13 +4645,20 @@ static int _wrap_CoreSession_getState(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_getState");
+  SWIG_check_num_args("getState",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("getState",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_getState",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (char *)(arg1)->getState();
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3789,13 +4674,18 @@ static int _wrap_CoreSession_recordFile(lua_State* L) {
   int arg5 = (int) 0 ;
   int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(lua_gettop(L)>=3 && !lua_isnumber(L,3)) SWIG_fail_arg(3);
-  if(lua_gettop(L)>=4 && !lua_isnumber(L,4)) SWIG_fail_arg(4);
-  if(lua_gettop(L)>=5 && !lua_isnumber(L,5)) SWIG_fail_arg(5);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_recordFile");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("recordFile",2,5)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("recordFile",1,"CoreSession *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("recordFile",2,"char *");
+  if(lua_gettop(L)>=3 && !lua_isnumber(L,3)) SWIG_fail_arg("recordFile",3,"int");
+  if(lua_gettop(L)>=4 && !lua_isnumber(L,4)) SWIG_fail_arg("recordFile",4,"int");
+  if(lua_gettop(L)>=5 && !lua_isnumber(L,5)) SWIG_fail_arg("recordFile",5,"int");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_recordFile",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   if(lua_gettop(L)>=3){
     arg3 = (int)lua_tonumber(L, 3);
   }
@@ -3810,6 +4700,8 @@ static int _wrap_CoreSession_recordFile(lua_State* L) {
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3825,25 +4717,38 @@ static int _wrap_CoreSession_originate(lua_State* L) {
   switch_state_handler_table_t *arg5 = (switch_state_handler_table_t *) NULL ;
   int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  if(!lua_isstring(L,3)) SWIG_fail_arg(3);
-  if(lua_gettop(L)>=4 && !lua_isnumber(L,4)) SWIG_fail_arg(4);
-  if(lua_gettop(L)>=5 && !lua_isuserdata(L,5)) SWIG_fail_arg(5);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_originate");
-  arg2=(CoreSession *)SWIG_MustGetPtr(L,2,SWIGTYPE_p_CoreSession,0,2,"CoreSession_originate");
-  arg3 = (char*)lua_tostring(L, 3);
+  SWIG_check_num_args("originate",3,5)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("originate",1,"CoreSession *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("originate",2,"CoreSession *");
+  if(!lua_isstring(L,3)) SWIG_fail_arg("originate",3,"char *");
+  if(lua_gettop(L)>=4 && !lua_isnumber(L,4)) SWIG_fail_arg("originate",4,"int");
+  if(lua_gettop(L)>=5 && !SWIG_isptrtype(L,5)) SWIG_fail_arg("originate",5,"switch_state_handler_table_t *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_originate",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_originate",2,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg3 = (char *)lua_tostring(L, 3);
   if(lua_gettop(L)>=4){
     arg4 = (int)lua_tonumber(L, 4);
   }
   if(lua_gettop(L)>=5){
-    arg5=(switch_state_handler_table_t *)SWIG_MustGetPtr(L,5,SWIGTYPE_p_switch_state_handler_table_t,0,5,"CoreSession_originate");
+    if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_switch_state_handler_table_t,0))){
+      SWIG_fail_ptr("CoreSession_originate",5,SWIGTYPE_p_switch_state_handler_table_t);
+    }
   }
   result = (int)(arg1)->originate(arg2,arg3,arg4,arg5);
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3854,13 +4759,20 @@ static int _wrap_CoreSession_destroy(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_destroy");
+  SWIG_check_num_args("destroy",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("destroy",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_destroy",1,SWIGTYPE_p_CoreSession);
+  }
+  
   (arg1)->destroy();
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3873,17 +4785,24 @@ static int _wrap_CoreSession_setDTMFCallback(lua_State* L) {
   void *arg2 = (void *) 0 ;
   char *arg3 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  if(!lua_isstring(L,3)) SWIG_fail_arg(3);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_setDTMFCallback");
-  arg2=((swig_lua_userdata*)(lua_touserdata(L,2)))->ptr;
-  arg3 = (char*)lua_tostring(L, 3);
+  SWIG_check_num_args("setDTMFCallback",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("setDTMFCallback",1,"CoreSession *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("setDTMFCallback",2,"void *");
+  if(!lua_isstring(L,3)) SWIG_fail_arg("setDTMFCallback",3,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_setDTMFCallback",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"CoreSession_setDTMFCallback");
+  arg3 = (char *)lua_tostring(L, 3);
   (arg1)->setDTMFCallback(arg2,arg3);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3896,15 +4815,22 @@ static int _wrap_CoreSession_speak(lua_State* L) {
   char *arg2 = (char *) 0 ;
   int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_speak");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("speak",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("speak",1,"CoreSession *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("speak",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_speak",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   result = (int)(arg1)->speak(arg2);
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3917,17 +4843,24 @@ static int _wrap_CoreSession_set_tts_parms(lua_State* L) {
   char *arg2 = (char *) 0 ;
   char *arg3 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(!lua_isstring(L,3)) SWIG_fail_arg(3);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_set_tts_parms");
-  arg2 = (char*)lua_tostring(L, 2);
-  arg3 = (char*)lua_tostring(L, 3);
+  SWIG_check_num_args("set_tts_parms",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("set_tts_parms",1,"CoreSession *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("set_tts_parms",2,"char *");
+  if(!lua_isstring(L,3)) SWIG_fail_arg("set_tts_parms",3,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_set_tts_parms",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
+  arg3 = (char *)lua_tostring(L, 3);
   (arg1)->set_tts_parms(arg2,arg3);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3940,15 +4873,22 @@ static int _wrap_CoreSession_collectDigits__SWIG_0(lua_State* L) {
   int arg2 ;
   int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isnumber(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_collectDigits");
+  SWIG_check_num_args("collectDigits",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("collectDigits",1,"CoreSession *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("collectDigits",2,"int");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_collectDigits",1,SWIGTYPE_p_CoreSession);
+  }
+  
   arg2 = (int)lua_tonumber(L, 2);
   result = (int)(arg1)->collectDigits(arg2);
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3962,10 +4902,15 @@ static int _wrap_CoreSession_collectDigits__SWIG_1(lua_State* L) {
   int arg3 ;
   int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isnumber(L,2)) SWIG_fail_arg(2);
-  if(!lua_isnumber(L,3)) SWIG_fail_arg(3);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_collectDigits");
+  SWIG_check_num_args("collectDigits",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("collectDigits",1,"CoreSession *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("collectDigits",2,"int");
+  if(!lua_isnumber(L,3)) SWIG_fail_arg("collectDigits",3,"int");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_collectDigits",1,SWIGTYPE_p_CoreSession);
+  }
+  
   arg2 = (int)lua_tonumber(L, 2);
   arg3 = (int)lua_tonumber(L, 3);
   result = (int)(arg1)->collectDigits(arg2,arg3);
@@ -3973,6 +4918,8 @@ static int _wrap_CoreSession_collectDigits__SWIG_1(lua_State* L) {
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -3990,7 +4937,7 @@ static int _wrap_CoreSession_collectDigits(lua_State* L) {
     int _v;
     {
       void *ptr;
-      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
+      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
         _v = 0;
       } else {
         _v = 1;
@@ -4009,7 +4956,7 @@ static int _wrap_CoreSession_collectDigits(lua_State* L) {
     int _v;
     {
       void *ptr;
-      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
+      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
         _v = 0;
       } else {
         _v = 1;
@@ -4043,19 +4990,26 @@ static int _wrap_CoreSession_getDigits__SWIG_0(lua_State* L) {
   int arg4 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isnumber(L,2)) SWIG_fail_arg(2);
-  if(!lua_isstring(L,3)) SWIG_fail_arg(3);
-  if(!lua_isnumber(L,4)) SWIG_fail_arg(4);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_getDigits");
+  SWIG_check_num_args("getDigits",4,4)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("getDigits",1,"CoreSession *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("getDigits",2,"int");
+  if(!lua_isstring(L,3)) SWIG_fail_arg("getDigits",3,"char *");
+  if(!lua_isnumber(L,4)) SWIG_fail_arg("getDigits",4,"int");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_getDigits",1,SWIGTYPE_p_CoreSession);
+  }
+  
   arg2 = (int)lua_tonumber(L, 2);
-  arg3 = (char*)lua_tostring(L, 3);
+  arg3 = (char *)lua_tostring(L, 3);
   arg4 = (int)lua_tonumber(L, 4);
   result = (char *)(arg1)->getDigits(arg2,arg3,arg4);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4071,21 +5025,28 @@ static int _wrap_CoreSession_getDigits__SWIG_1(lua_State* L) {
   int arg5 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isnumber(L,2)) SWIG_fail_arg(2);
-  if(!lua_isstring(L,3)) SWIG_fail_arg(3);
-  if(!lua_isnumber(L,4)) SWIG_fail_arg(4);
-  if(!lua_isnumber(L,5)) SWIG_fail_arg(5);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_getDigits");
+  SWIG_check_num_args("getDigits",5,5)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("getDigits",1,"CoreSession *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("getDigits",2,"int");
+  if(!lua_isstring(L,3)) SWIG_fail_arg("getDigits",3,"char *");
+  if(!lua_isnumber(L,4)) SWIG_fail_arg("getDigits",4,"int");
+  if(!lua_isnumber(L,5)) SWIG_fail_arg("getDigits",5,"int");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_getDigits",1,SWIGTYPE_p_CoreSession);
+  }
+  
   arg2 = (int)lua_tonumber(L, 2);
-  arg3 = (char*)lua_tostring(L, 3);
+  arg3 = (char *)lua_tostring(L, 3);
   arg4 = (int)lua_tonumber(L, 4);
   arg5 = (int)lua_tonumber(L, 5);
   result = (char *)(arg1)->getDigits(arg2,arg3,arg4,arg5);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4103,7 +5064,7 @@ static int _wrap_CoreSession_getDigits(lua_State* L) {
     int _v;
     {
       void *ptr;
-      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
+      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
         _v = 0;
       } else {
         _v = 1;
@@ -4132,7 +5093,7 @@ static int _wrap_CoreSession_getDigits(lua_State* L) {
     int _v;
     {
       void *ptr;
-      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
+      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
         _v = 0;
       } else {
         _v = 1;
@@ -4176,23 +5137,30 @@ static int _wrap_CoreSession_transfer(lua_State* L) {
   char *arg4 = (char *) NULL ;
   int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(lua_gettop(L)>=3 && !lua_isstring(L,3)) SWIG_fail_arg(3);
-  if(lua_gettop(L)>=4 && !lua_isstring(L,4)) SWIG_fail_arg(4);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_transfer");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("transfer",2,4)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("transfer",1,"CoreSession *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("transfer",2,"char *");
+  if(lua_gettop(L)>=3 && !lua_isstring(L,3)) SWIG_fail_arg("transfer",3,"char *");
+  if(lua_gettop(L)>=4 && !lua_isstring(L,4)) SWIG_fail_arg("transfer",4,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_transfer",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   if(lua_gettop(L)>=3){
-    arg3 = (char*)lua_tostring(L, 3);
+    arg3 = (char *)lua_tostring(L, 3);
   }
   if(lua_gettop(L)>=4){
-    arg4 = (char*)lua_tostring(L, 4);
+    arg4 = (char *)lua_tostring(L, 4);
   }
   result = (int)(arg1)->transfer(arg2,arg3,arg4);
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4209,23 +5177,30 @@ static int _wrap_CoreSession_read(lua_State* L) {
   char *arg6 = (char *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isnumber(L,2)) SWIG_fail_arg(2);
-  if(!lua_isnumber(L,3)) SWIG_fail_arg(3);
-  if(!lua_isstring(L,4)) SWIG_fail_arg(4);
-  if(!lua_isnumber(L,5)) SWIG_fail_arg(5);
-  if(!lua_isstring(L,6)) SWIG_fail_arg(6);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_read");
+  SWIG_check_num_args("read",6,6)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("read",1,"CoreSession *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("read",2,"int");
+  if(!lua_isnumber(L,3)) SWIG_fail_arg("read",3,"int");
+  if(!lua_isstring(L,4)) SWIG_fail_arg("read",4,"char const *");
+  if(!lua_isnumber(L,5)) SWIG_fail_arg("read",5,"int");
+  if(!lua_isstring(L,6)) SWIG_fail_arg("read",6,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_read",1,SWIGTYPE_p_CoreSession);
+  }
+  
   arg2 = (int)lua_tonumber(L, 2);
   arg3 = (int)lua_tonumber(L, 3);
-  arg4 = (char*)lua_tostring(L, 4);
+  arg4 = (char *)lua_tostring(L, 4);
   arg5 = (int)lua_tonumber(L, 5);
-  arg6 = (char*)lua_tostring(L, 6);
+  arg6 = (char *)lua_tostring(L, 6);
   result = (char *)(arg1)->read(arg2,arg3,(char const *)arg4,arg5,(char const *)arg6);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4246,33 +5221,40 @@ static int _wrap_CoreSession_playAndGetDigits(lua_State* L) {
   char *arg10 = (char *) NULL ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isnumber(L,2)) SWIG_fail_arg(2);
-  if(!lua_isnumber(L,3)) SWIG_fail_arg(3);
-  if(!lua_isnumber(L,4)) SWIG_fail_arg(4);
-  if(!lua_isnumber(L,5)) SWIG_fail_arg(5);
-  if(!lua_isstring(L,6)) SWIG_fail_arg(6);
-  if(!lua_isstring(L,7)) SWIG_fail_arg(7);
-  if(!lua_isstring(L,8)) SWIG_fail_arg(8);
-  if(!lua_isstring(L,9)) SWIG_fail_arg(9);
-  if(lua_gettop(L)>=10 && !lua_isstring(L,10)) SWIG_fail_arg(10);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_playAndGetDigits");
+  SWIG_check_num_args("playAndGetDigits",9,10)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("playAndGetDigits",1,"CoreSession *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("playAndGetDigits",2,"int");
+  if(!lua_isnumber(L,3)) SWIG_fail_arg("playAndGetDigits",3,"int");
+  if(!lua_isnumber(L,4)) SWIG_fail_arg("playAndGetDigits",4,"int");
+  if(!lua_isnumber(L,5)) SWIG_fail_arg("playAndGetDigits",5,"int");
+  if(!lua_isstring(L,6)) SWIG_fail_arg("playAndGetDigits",6,"char *");
+  if(!lua_isstring(L,7)) SWIG_fail_arg("playAndGetDigits",7,"char *");
+  if(!lua_isstring(L,8)) SWIG_fail_arg("playAndGetDigits",8,"char *");
+  if(!lua_isstring(L,9)) SWIG_fail_arg("playAndGetDigits",9,"char *");
+  if(lua_gettop(L)>=10 && !lua_isstring(L,10)) SWIG_fail_arg("playAndGetDigits",10,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_playAndGetDigits",1,SWIGTYPE_p_CoreSession);
+  }
+  
   arg2 = (int)lua_tonumber(L, 2);
   arg3 = (int)lua_tonumber(L, 3);
   arg4 = (int)lua_tonumber(L, 4);
   arg5 = (int)lua_tonumber(L, 5);
-  arg6 = (char*)lua_tostring(L, 6);
-  arg7 = (char*)lua_tostring(L, 7);
-  arg8 = (char*)lua_tostring(L, 8);
-  arg9 = (char*)lua_tostring(L, 9);
+  arg6 = (char *)lua_tostring(L, 6);
+  arg7 = (char *)lua_tostring(L, 7);
+  arg8 = (char *)lua_tostring(L, 8);
+  arg9 = (char *)lua_tostring(L, 9);
   if(lua_gettop(L)>=10){
-    arg10 = (char*)lua_tostring(L, 10);
+    arg10 = (char *)lua_tostring(L, 10);
   }
   result = (char *)(arg1)->playAndGetDigits(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char const *)arg10);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4286,11 +5268,16 @@ static int _wrap_CoreSession_streamFile(lua_State* L) {
   int arg3 = (int) 0 ;
   int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(lua_gettop(L)>=3 && !lua_isnumber(L,3)) SWIG_fail_arg(3);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_streamFile");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("streamFile",2,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("streamFile",1,"CoreSession *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("streamFile",2,"char *");
+  if(lua_gettop(L)>=3 && !lua_isnumber(L,3)) SWIG_fail_arg("streamFile",3,"int");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_streamFile",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   if(lua_gettop(L)>=3){
     arg3 = (int)lua_tonumber(L, 3);
   }
@@ -4299,6 +5286,8 @@ static int _wrap_CoreSession_streamFile(lua_State* L) {
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4312,10 +5301,15 @@ static int _wrap_CoreSession_sleep(lua_State* L) {
   int arg3 = (int) 0 ;
   int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isnumber(L,2)) SWIG_fail_arg(2);
-  if(lua_gettop(L)>=3 && !lua_isnumber(L,3)) SWIG_fail_arg(3);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_sleep");
+  SWIG_check_num_args("sleep",2,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("sleep",1,"CoreSession *");
+  if(!lua_isnumber(L,2)) SWIG_fail_arg("sleep",2,"int");
+  if(lua_gettop(L)>=3 && !lua_isnumber(L,3)) SWIG_fail_arg("sleep",3,"int");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_sleep",1,SWIGTYPE_p_CoreSession);
+  }
+  
   arg2 = (int)lua_tonumber(L, 2);
   if(lua_gettop(L)>=3){
     arg3 = (int)lua_tonumber(L, 3);
@@ -4325,6 +5319,8 @@ static int _wrap_CoreSession_sleep(lua_State* L) {
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4336,13 +5332,20 @@ static int _wrap_CoreSession_flushEvents(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_flushEvents");
+  SWIG_check_num_args("flushEvents",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("flushEvents",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_flushEvents",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (int)(arg1)->flushEvents();
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4354,13 +5357,20 @@ static int _wrap_CoreSession_flushDigits(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_flushDigits");
+  SWIG_check_num_args("flushDigits",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("flushDigits",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_flushDigits",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (int)(arg1)->flushDigits();
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4373,15 +5383,22 @@ static int _wrap_CoreSession_setAutoHangup(lua_State* L) {
   bool arg2 ;
   int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isboolean(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_setAutoHangup");
-  arg2 = (bool)lua_toboolean(L, 2);
+  SWIG_check_num_args("setAutoHangup",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("setAutoHangup",1,"CoreSession *");
+  if(!lua_isboolean(L,2)) SWIG_fail_arg("setAutoHangup",2,"bool");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_setAutoHangup",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2 = (lua_toboolean(L, 2)!=0);
   result = (int)(arg1)->setAutoHangup(arg2);
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4393,15 +5410,22 @@ static int _wrap_CoreSession_setHangupHook(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   void *arg2 = (void *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_setHangupHook");
-  arg2=((swig_lua_userdata*)(lua_touserdata(L,2)))->ptr;
+  SWIG_check_num_args("setHangupHook",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("setHangupHook",1,"CoreSession *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("setHangupHook",2,"void *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_setHangupHook",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"CoreSession_setHangupHook");
   (arg1)->setHangupHook(arg2);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4413,13 +5437,20 @@ static int _wrap_CoreSession_ready(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   bool result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_ready");
+  SWIG_check_num_args("ready",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ready",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_ready",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (bool)(arg1)->ready();
   SWIG_arg=0;
-  lua_pushboolean(L,(int)result); SWIG_arg++;
+  lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4431,13 +5462,20 @@ static int _wrap_CoreSession_bridged(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   bool result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_bridged");
+  SWIG_check_num_args("bridged",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("bridged",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_bridged",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (bool)(arg1)->bridged();
   SWIG_arg=0;
-  lua_pushboolean(L,(int)result); SWIG_arg++;
+  lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4449,13 +5487,20 @@ static int _wrap_CoreSession_answered(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   bool result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_answered");
+  SWIG_check_num_args("answered",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("answered",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_answered",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (bool)(arg1)->answered();
   SWIG_arg=0;
-  lua_pushboolean(L,(int)result); SWIG_arg++;
+  lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4467,13 +5512,20 @@ static int _wrap_CoreSession_mediaReady(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   bool result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_mediaReady");
+  SWIG_check_num_args("mediaReady",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("mediaReady",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_mediaReady",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (bool)(arg1)->mediaReady();
   SWIG_arg=0;
-  lua_pushboolean(L,(int)result); SWIG_arg++;
+  lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4485,15 +5537,26 @@ static int _wrap_CoreSession_waitForAnswer(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   CoreSession *arg2 = (CoreSession *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_waitForAnswer");
-  arg2=(CoreSession *)SWIG_MustGetPtr(L,2,SWIGTYPE_p_CoreSession,0,2,"CoreSession_waitForAnswer");
+  SWIG_check_num_args("waitForAnswer",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("waitForAnswer",1,"CoreSession *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("waitForAnswer",2,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_waitForAnswer",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_waitForAnswer",2,SWIGTYPE_p_CoreSession);
+  }
+  
   (arg1)->waitForAnswer(arg2);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4506,19 +5569,26 @@ static int _wrap_CoreSession_execute(lua_State* L) {
   char *arg2 = (char *) 0 ;
   char *arg3 = (char *) NULL ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(lua_gettop(L)>=3 && !lua_isstring(L,3)) SWIG_fail_arg(3);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_execute");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("execute",2,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("execute",1,"CoreSession *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("execute",2,"char const *");
+  if(lua_gettop(L)>=3 && !lua_isstring(L,3)) SWIG_fail_arg("execute",3,"char const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_execute",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   if(lua_gettop(L)>=3){
-    arg3 = (char*)lua_tostring(L, 3);
+    arg3 = (char *)lua_tostring(L, 3);
   }
   (arg1)->execute((char const *)arg2,(char const *)arg3);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4530,15 +5600,26 @@ static int _wrap_CoreSession_sendEvent(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   Event *arg2 = (Event *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_sendEvent");
-  arg2=(Event *)SWIG_MustGetPtr(L,2,SWIGTYPE_p_Event,0,2,"CoreSession_sendEvent");
+  SWIG_check_num_args("sendEvent",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("sendEvent",1,"CoreSession *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("sendEvent",2,"Event *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_sendEvent",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Event,0))){
+    SWIG_fail_ptr("CoreSession_sendEvent",2,SWIGTYPE_p_Event);
+  }
+  
   (arg1)->sendEvent(arg2);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4550,15 +5631,26 @@ static int _wrap_CoreSession_setEventData(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   Event *arg2 = (Event *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_setEventData");
-  arg2=(Event *)SWIG_MustGetPtr(L,2,SWIGTYPE_p_Event,0,2,"CoreSession_setEventData");
+  SWIG_check_num_args("setEventData",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("setEventData",1,"CoreSession *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("setEventData",2,"Event *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_setEventData",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Event,0))){
+    SWIG_fail_ptr("CoreSession_setEventData",2,SWIGTYPE_p_Event);
+  }
+  
   (arg1)->setEventData(arg2);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4570,13 +5662,20 @@ static int _wrap_CoreSession_getXMLCDR(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_getXMLCDR");
+  SWIG_check_num_args("getXMLCDR",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("getXMLCDR",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_getXMLCDR",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (char *)(arg1)->getXMLCDR();
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4588,13 +5687,20 @@ static int _wrap_CoreSession_begin_allow_threads(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   bool result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_begin_allow_threads");
+  SWIG_check_num_args("begin_allow_threads",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("begin_allow_threads",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_begin_allow_threads",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (bool)(arg1)->begin_allow_threads();
   SWIG_arg=0;
-  lua_pushboolean(L,(int)result); SWIG_arg++;
+  lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4606,13 +5712,20 @@ static int _wrap_CoreSession_end_allow_threads(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   bool result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_end_allow_threads");
+  SWIG_check_num_args("end_allow_threads",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("end_allow_threads",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_end_allow_threads",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (bool)(arg1)->end_allow_threads();
   SWIG_arg=0;
-  lua_pushboolean(L,(int)result); SWIG_arg++;
+  lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4624,13 +5737,20 @@ static int _wrap_CoreSession_get_uuid(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_get_uuid");
+  SWIG_check_num_args("get_uuid",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("get_uuid",1,"CoreSession const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_get_uuid",1,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (char *)((CoreSession const *)arg1)->get_uuid();
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4642,8 +5762,13 @@ static int _wrap_CoreSession_get_cb_args(lua_State* L) {
   CoreSession *arg1 = (CoreSession *) 0 ;
   switch_input_args_t *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_get_cb_args");
+  SWIG_check_num_args("get_cb_args",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("get_cb_args",1,"CoreSession const *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_get_cb_args",1,SWIGTYPE_p_CoreSession);
+  }
+  
   {
     switch_input_args_t const &_result_ref = ((CoreSession const *)arg1)->get_cb_args();
     result = (switch_input_args_t *) &_result_ref;
@@ -4652,6 +5777,8 @@ static int _wrap_CoreSession_get_cb_args(lua_State* L) {
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_switch_input_args_t,0); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4662,13 +5789,20 @@ static int _wrap_CoreSession_check_hangup_hook(lua_State* L) {
   int SWIG_arg = -1;
   CoreSession *arg1 = (CoreSession *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_check_hangup_hook");
+  SWIG_check_num_args("check_hangup_hook",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("check_hangup_hook",1,"CoreSession *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_check_hangup_hook",1,SWIGTYPE_p_CoreSession);
+  }
+  
   (arg1)->check_hangup_hook();
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4681,26 +5815,34 @@ static int _wrap_CoreSession_run_dtmf_callback(lua_State* L) {
   void *arg2 = (void *) 0 ;
   switch_input_type_t arg3 ;
   switch_status_t result;
+  switch_input_type_t *argp3 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  if(!lua_isuserdata(L,3)) SWIG_fail_arg(3);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"CoreSession_run_dtmf_callback");
-  arg2=((swig_lua_userdata*)(lua_touserdata(L,2)))->ptr;
-  {
-    switch_input_type_t * argp;
-    if(SWIG_ConvertPtr(L,3,(void**)(&argp),SWIGTYPE_p_switch_input_type_t,0)) SWIG_fail;
-    arg3 = *argp;
+  SWIG_check_num_args("run_dtmf_callback",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("run_dtmf_callback",1,"CoreSession *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("run_dtmf_callback",2,"void *");
+  if(!lua_isuserdata(L,3)) SWIG_fail_arg("run_dtmf_callback",3,"switch_input_type_t");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("CoreSession_run_dtmf_callback",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"CoreSession_run_dtmf_callback");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_switch_input_type_t,0))){
+    SWIG_fail_ptr("CoreSession_run_dtmf_callback",3,SWIGTYPE_p_switch_input_type_t);
   }
+  arg3 = *argp3;
+  
   result = (arg1)->run_dtmf_callback(arg2,arg3);
   SWIG_arg=0;
   {
-    switch_status_t * resultptr;
-    resultptr = new switch_status_t((switch_status_t &) result);
+    switch_status_t * resultptr = new switch_status_t((switch_status_t &) result);
     SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_switch_status_t,1); SWIG_arg++;
   }
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4760,35 +5902,39 @@ static swig_lua_method swig_CoreSession_methods[] = {
     {0,0}
 };
 static swig_lua_attribute swig_CoreSession_attributes[] = {
-    { "session",_wrap_CoreSession_session_get, _wrap_CoreSession_session_set},
-    { "channel",_wrap_CoreSession_channel_get, _wrap_CoreSession_channel_set},
-    { "flags",_wrap_CoreSession_flags_get, _wrap_CoreSession_flags_set},
-    { "allocated",_wrap_CoreSession_allocated_get, _wrap_CoreSession_allocated_set},
-    { "cb_state",_wrap_CoreSession_cb_state_get, _wrap_CoreSession_cb_state_set},
-    { "hook_state",_wrap_CoreSession_hook_state_get, _wrap_CoreSession_hook_state_set},
-    { "cause",_wrap_CoreSession_cause_get, _wrap_CoreSession_cause_set},
-    { "uuid",_wrap_CoreSession_uuid_get, _wrap_CoreSession_uuid_set},
-    { "tts_name",_wrap_CoreSession_tts_name_get, _wrap_CoreSession_tts_name_set},
-    { "voice_name",_wrap_CoreSession_voice_name_get, _wrap_CoreSession_voice_name_set},
+    { "session", _wrap_CoreSession_session_get, _wrap_CoreSession_session_set},
+    { "channel", _wrap_CoreSession_channel_get, _wrap_CoreSession_channel_set},
+    { "flags", _wrap_CoreSession_flags_get, _wrap_CoreSession_flags_set},
+    { "allocated", _wrap_CoreSession_allocated_get, _wrap_CoreSession_allocated_set},
+    { "cb_state", _wrap_CoreSession_cb_state_get, _wrap_CoreSession_cb_state_set},
+    { "hook_state", _wrap_CoreSession_hook_state_get, _wrap_CoreSession_hook_state_set},
+    { "cause", _wrap_CoreSession_cause_get, _wrap_CoreSession_cause_set},
+    { "uuid", _wrap_CoreSession_uuid_get, _wrap_CoreSession_uuid_set},
+    { "tts_name", _wrap_CoreSession_tts_name_get, _wrap_CoreSession_tts_name_set},
+    { "voice_name", _wrap_CoreSession_voice_name_get, _wrap_CoreSession_voice_name_set},
     {0,0,0}
 };
 static swig_lua_class *swig_CoreSession_bases[] = {0};
-swig_lua_class _wrap_class_CoreSession = { "CoreSession", &SWIGTYPE_p_CoreSession,0, swig_delete_CoreSession, swig_CoreSession_methods, swig_CoreSession_attributes, swig_CoreSession_bases };
+static const char *swig_CoreSession_base_names[] = {0};
+static swig_lua_class _wrap_class_CoreSession = { "CoreSession", &SWIGTYPE_p_CoreSession,0, swig_delete_CoreSession, swig_CoreSession_methods, swig_CoreSession_attributes, swig_CoreSession_bases, swig_CoreSession_base_names };
 
 static int _wrap_console_log(lua_State* L) {
   int SWIG_arg = -1;
   char *arg1 = (char *) 0 ;
   char *arg2 = (char *) 0 ;
   
-  if(!lua_isstring(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1 = (char*)lua_tostring(L, 1);
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("console_log",2,2)
+  if(!lua_isstring(L,1)) SWIG_fail_arg("console_log",1,"char *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("console_log",2,"char *");
+  arg1 = (char *)lua_tostring(L, 1);
+  arg2 = (char *)lua_tostring(L, 2);
   console_log(arg1,arg2);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4799,13 +5945,16 @@ static int _wrap_console_clean_log(lua_State* L) {
   int SWIG_arg = -1;
   char *arg1 = (char *) 0 ;
   
-  if(!lua_isstring(L,1)) SWIG_fail_arg(1);
-  arg1 = (char*)lua_tostring(L, 1);
+  SWIG_check_num_args("console_clean_log",1,1)
+  if(!lua_isstring(L,1)) SWIG_fail_arg("console_clean_log",1,"char *");
+  arg1 = (char *)lua_tostring(L, 1);
   console_clean_log(arg1);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4816,13 +5965,16 @@ static int _wrap_msleep(lua_State* L) {
   int SWIG_arg = -1;
   unsigned int arg1 ;
   
-  if(!lua_isnumber(L,1)) SWIG_fail_arg(1);
+  SWIG_check_num_args("msleep",1,1)
+  if(!lua_isnumber(L,1)) SWIG_fail_arg("msleep",1,"unsigned int");
   arg1 = (unsigned int)lua_tonumber(L, 1);
   msleep(arg1);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4834,15 +5986,26 @@ static int _wrap_bridge(lua_State* L) {
   CoreSession *arg1 = 0 ;
   CoreSession *arg2 = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(CoreSession *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_CoreSession,0,1,"bridge");
-  arg2=(CoreSession *)SWIG_MustGetPtr(L,2,SWIGTYPE_p_CoreSession,0,2,"bridge");
+  SWIG_check_num_args("bridge",2,2)
+  if(!lua_isuserdata(L,1)) SWIG_fail_arg("bridge",1,"CoreSession &");
+  if(!lua_isuserdata(L,2)) SWIG_fail_arg("bridge",2,"CoreSession &");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("bridge",1,SWIGTYPE_p_CoreSession);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("bridge",2,SWIGTYPE_p_CoreSession);
+  }
+  
   bridge(*arg1,*arg2);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4854,17 +6017,23 @@ static int _wrap_hanguphook(lua_State* L) {
   switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
   switch_status_t result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(switch_core_session_t *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_switch_core_session_t,0,1,"hanguphook");
+  SWIG_check_num_args("hanguphook",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("hanguphook",1,"switch_core_session_t *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_switch_core_session_t,0))){
+    SWIG_fail_ptr("hanguphook",1,SWIGTYPE_p_switch_core_session_t);
+  }
+  
   result = hanguphook(arg1);
   SWIG_arg=0;
   {
-    switch_status_t * resultptr;
-    resultptr = new switch_status_t((switch_status_t &) result);
+    switch_status_t * resultptr = new switch_status_t((switch_status_t &) result);
     SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_switch_status_t,1); SWIG_arg++;
   }
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4879,30 +6048,38 @@ static int _wrap_dtmf_callback(lua_State* L) {
   void *arg4 = (void *) 0 ;
   unsigned int arg5 ;
   switch_status_t result;
+  switch_input_type_t *argp3 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  if(!lua_isuserdata(L,3)) SWIG_fail_arg(3);
-  if(!lua_isuserdata(L,4)) SWIG_fail_arg(4);
-  if(!lua_isnumber(L,5)) SWIG_fail_arg(5);
-  arg1=(switch_core_session_t *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_switch_core_session_t,0,1,"dtmf_callback");
-  arg2=((swig_lua_userdata*)(lua_touserdata(L,2)))->ptr;
-  {
-    switch_input_type_t * argp;
-    if(SWIG_ConvertPtr(L,3,(void**)(&argp),SWIGTYPE_p_switch_input_type_t,0)) SWIG_fail;
-    arg3 = *argp;
+  SWIG_check_num_args("dtmf_callback",5,5)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("dtmf_callback",1,"switch_core_session_t *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("dtmf_callback",2,"void *");
+  if(!lua_isuserdata(L,3)) SWIG_fail_arg("dtmf_callback",3,"switch_input_type_t");
+  if(!SWIG_isptrtype(L,4)) SWIG_fail_arg("dtmf_callback",4,"void *");
+  if(!lua_isnumber(L,5)) SWIG_fail_arg("dtmf_callback",5,"unsigned int");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_switch_core_session_t,0))){
+    SWIG_fail_ptr("dtmf_callback",1,SWIGTYPE_p_switch_core_session_t);
+  }
+  
+  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"dtmf_callback");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_switch_input_type_t,0))){
+    SWIG_fail_ptr("dtmf_callback",3,SWIGTYPE_p_switch_input_type_t);
   }
-  arg4=((swig_lua_userdata*)(lua_touserdata(L,4)))->ptr;
+  arg3 = *argp3;
+  
+  arg4=(void *)SWIG_MustGetPtr(L,4,0,0,4,"dtmf_callback");
   arg5 = (unsigned int)lua_tonumber(L, 5);
   result = dtmf_callback(arg1,arg2,arg3,arg4,arg5);
   SWIG_arg=0;
   {
-    switch_status_t * resultptr;
-    resultptr = new switch_status_t((switch_status_t &) result);
+    switch_status_t * resultptr = new switch_status_t((switch_status_t &) result);
     SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_switch_status_t,1); SWIG_arg++;
   }
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4913,11 +6090,14 @@ static int _wrap_new_Session__SWIG_0(lua_State* L) {
   int SWIG_arg = -1;
   LUA::Session *result = 0 ;
   
+  SWIG_check_num_args("LUA::Session",0,0)
   result = (LUA::Session *)new LUA::Session();
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_LUA__Session,1); SWIG_arg++; result->setLUA(L);
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4930,15 +6110,22 @@ static int _wrap_new_Session__SWIG_1(lua_State* L) {
   CoreSession *arg2 = (CoreSession *) 0 ;
   LUA::Session *result = 0 ;
   
-  if(!lua_isstring(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1 = (char*)lua_tostring(L, 1);
-  arg2=(CoreSession *)SWIG_MustGetPtr(L,2,SWIGTYPE_p_CoreSession,0,2,"new_Session");
+  SWIG_check_num_args("LUA::Session",2,2)
+  if(!lua_isstring(L,1)) SWIG_fail_arg("LUA::Session",1,"char *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("LUA::Session",2,"CoreSession *");
+  arg1 = (char *)lua_tostring(L, 1);
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("new_Session",2,SWIGTYPE_p_CoreSession);
+  }
+  
   result = (LUA::Session *)new LUA::Session(arg1,arg2);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_LUA__Session,1); SWIG_arg++; result->setLUA(L);
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4950,13 +6137,16 @@ static int _wrap_new_Session__SWIG_2(lua_State* L) {
   char *arg1 = (char *) 0 ;
   LUA::Session *result = 0 ;
   
-  if(!lua_isstring(L,1)) SWIG_fail_arg(1);
-  arg1 = (char*)lua_tostring(L, 1);
+  SWIG_check_num_args("LUA::Session",1,1)
+  if(!lua_isstring(L,1)) SWIG_fail_arg("LUA::Session",1,"char *");
+  arg1 = (char *)lua_tostring(L, 1);
   result = (LUA::Session *)new LUA::Session(arg1);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_LUA__Session,1); SWIG_arg++; result->setLUA(L);
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4968,13 +6158,20 @@ static int _wrap_new_Session__SWIG_3(lua_State* L) {
   switch_core_session_t *arg1 = (switch_core_session_t *) 0 ;
   LUA::Session *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(switch_core_session_t *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_switch_core_session_t,0,1,"new_Session");
+  SWIG_check_num_args("LUA::Session",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("LUA::Session",1,"switch_core_session_t *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_switch_core_session_t,0))){
+    SWIG_fail_ptr("new_Session",1,SWIGTYPE_p_switch_core_session_t);
+  }
+  
   result = (LUA::Session *)new LUA::Session(arg1);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_LUA__Session,1); SWIG_arg++; result->setLUA(L);
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -4995,7 +6192,7 @@ static int _wrap_new_Session(lua_State* L) {
     int _v;
     {
       void *ptr;
-      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_switch_core_session_t, 0)) {
+      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_switch_core_session_t, 0)) {
         _v = 0;
       } else {
         _v = 1;
@@ -5022,7 +6219,7 @@ static int _wrap_new_Session(lua_State* L) {
     if (_v) {
       {
         void *ptr;
-        if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
+        if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_CoreSession, 0)) {
           _v = 0;
         } else {
           _v = 1;
@@ -5043,14 +6240,21 @@ static int _wrap_delete_Session(lua_State* L) {
   int SWIG_arg = -1;
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"delete_Session");
+  SWIG_check_num_args("LUA::~Session",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("LUA::~Session",1,"LUA::Session *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,SWIG_POINTER_DISOWN))){
+    SWIG_fail_ptr("delete_Session",1,SWIGTYPE_p_LUA__Session);
+  }
+  
   delete arg1;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5061,13 +6265,20 @@ static int _wrap_Session_destroy(lua_State* L) {
   int SWIG_arg = -1;
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_destroy");
+  SWIG_check_num_args("destroy",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("destroy",1,"LUA::Session *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_destroy",1,SWIGTYPE_p_LUA__Session);
+  }
+  
   (arg1)->destroy();
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5079,13 +6290,20 @@ static int _wrap_Session_begin_allow_threads(lua_State* L) {
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   bool result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_begin_allow_threads");
+  SWIG_check_num_args("begin_allow_threads",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("begin_allow_threads",1,"LUA::Session *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_begin_allow_threads",1,SWIGTYPE_p_LUA__Session);
+  }
+  
   result = (bool)(arg1)->begin_allow_threads();
   SWIG_arg=0;
-  lua_pushboolean(L,(int)result); SWIG_arg++;
+  lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5097,13 +6315,20 @@ static int _wrap_Session_end_allow_threads(lua_State* L) {
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   bool result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_end_allow_threads");
+  SWIG_check_num_args("end_allow_threads",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("end_allow_threads",1,"LUA::Session *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_end_allow_threads",1,SWIGTYPE_p_LUA__Session);
+  }
+  
   result = (bool)(arg1)->end_allow_threads();
   SWIG_arg=0;
-  lua_pushboolean(L,(int)result); SWIG_arg++;
+  lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5114,13 +6339,20 @@ static int _wrap_Session_check_hangup_hook(lua_State* L) {
   int SWIG_arg = -1;
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_check_hangup_hook");
+  SWIG_check_num_args("check_hangup_hook",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("check_hangup_hook",1,"LUA::Session *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_check_hangup_hook",1,SWIGTYPE_p_LUA__Session);
+  }
+  
   (arg1)->check_hangup_hook();
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5133,26 +6365,34 @@ static int _wrap_Session_run_dtmf_callback(lua_State* L) {
   void *arg2 = (void *) 0 ;
   switch_input_type_t arg3 ;
   switch_status_t result;
+  switch_input_type_t *argp3 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  if(!lua_isuserdata(L,3)) SWIG_fail_arg(3);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_run_dtmf_callback");
-  arg2=((swig_lua_userdata*)(lua_touserdata(L,2)))->ptr;
-  {
-    switch_input_type_t * argp;
-    if(SWIG_ConvertPtr(L,3,(void**)(&argp),SWIGTYPE_p_switch_input_type_t,0)) SWIG_fail;
-    arg3 = *argp;
+  SWIG_check_num_args("run_dtmf_callback",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("run_dtmf_callback",1,"LUA::Session *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("run_dtmf_callback",2,"void *");
+  if(!lua_isuserdata(L,3)) SWIG_fail_arg("run_dtmf_callback",3,"switch_input_type_t");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_run_dtmf_callback",1,SWIGTYPE_p_LUA__Session);
+  }
+  
+  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"Session_run_dtmf_callback");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_switch_input_type_t,0))){
+    SWIG_fail_ptr("Session_run_dtmf_callback",3,SWIGTYPE_p_switch_input_type_t);
   }
+  arg3 = *argp3;
+  
   result = (arg1)->run_dtmf_callback(arg2,arg3);
   SWIG_arg=0;
   {
-    switch_status_t * resultptr;
-    resultptr = new switch_status_t((switch_status_t &) result);
+    switch_status_t * resultptr = new switch_status_t((switch_status_t &) result);
     SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_switch_status_t,1); SWIG_arg++;
   }
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5163,13 +6403,20 @@ static int _wrap_Session_unsetInputCallback(lua_State* L) {
   int SWIG_arg = -1;
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_unsetInputCallback");
+  SWIG_check_num_args("unsetInputCallback",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("unsetInputCallback",1,"LUA::Session *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_unsetInputCallback",1,SWIGTYPE_p_LUA__Session);
+  }
+  
   (arg1)->unsetInputCallback();
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5182,17 +6429,24 @@ static int _wrap_Session_setInputCallback__SWIG_0(lua_State* L) {
   char *arg2 = (char *) 0 ;
   char *arg3 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(!lua_isstring(L,3)) SWIG_fail_arg(3);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_setInputCallback");
-  arg2 = (char*)lua_tostring(L, 2);
-  arg3 = (char*)lua_tostring(L, 3);
+  SWIG_check_num_args("setInputCallback",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("setInputCallback",1,"LUA::Session *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("setInputCallback",2,"char *");
+  if(!lua_isstring(L,3)) SWIG_fail_arg("setInputCallback",3,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_setInputCallback",1,SWIGTYPE_p_LUA__Session);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
+  arg3 = (char *)lua_tostring(L, 3);
   (arg1)->setInputCallback(arg2,arg3);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5204,15 +6458,22 @@ static int _wrap_Session_setInputCallback__SWIG_1(lua_State* L) {
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   char *arg2 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_setInputCallback");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("setInputCallback",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("setInputCallback",1,"LUA::Session *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("setInputCallback",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_setInputCallback",1,SWIGTYPE_p_LUA__Session);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   (arg1)->setInputCallback(arg2);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5230,7 +6491,7 @@ static int _wrap_Session_setInputCallback(lua_State* L) {
     int _v;
     {
       void *ptr;
-      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_LUA__Session, 0)) {
+      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_LUA__Session, 0)) {
         _v = 0;
       } else {
         _v = 1;
@@ -5249,7 +6510,7 @@ static int _wrap_Session_setInputCallback(lua_State* L) {
     int _v;
     {
       void *ptr;
-      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_LUA__Session, 0)) {
+      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_LUA__Session, 0)) {
         _v = 0;
       } else {
         _v = 1;
@@ -5281,17 +6542,24 @@ static int _wrap_Session_setHangupHook__SWIG_0(lua_State* L) {
   char *arg2 = (char *) 0 ;
   char *arg3 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(!lua_isstring(L,3)) SWIG_fail_arg(3);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_setHangupHook");
-  arg2 = (char*)lua_tostring(L, 2);
-  arg3 = (char*)lua_tostring(L, 3);
+  SWIG_check_num_args("setHangupHook",3,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("setHangupHook",1,"LUA::Session *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("setHangupHook",2,"char *");
+  if(!lua_isstring(L,3)) SWIG_fail_arg("setHangupHook",3,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_setHangupHook",1,SWIGTYPE_p_LUA__Session);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
+  arg3 = (char *)lua_tostring(L, 3);
   (arg1)->setHangupHook(arg2,arg3);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5303,15 +6571,22 @@ static int _wrap_Session_setHangupHook__SWIG_1(lua_State* L) {
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   char *arg2 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_setHangupHook");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("setHangupHook",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("setHangupHook",1,"LUA::Session *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("setHangupHook",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_setHangupHook",1,SWIGTYPE_p_LUA__Session);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   (arg1)->setHangupHook(arg2);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5329,7 +6604,7 @@ static int _wrap_Session_setHangupHook(lua_State* L) {
     int _v;
     {
       void *ptr;
-      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_LUA__Session, 0)) {
+      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_LUA__Session, 0)) {
         _v = 0;
       } else {
         _v = 1;
@@ -5348,7 +6623,7 @@ static int _wrap_Session_setHangupHook(lua_State* L) {
     int _v;
     {
       void *ptr;
-      if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_LUA__Session, 0)) {
+      if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_LUA__Session, 0)) {
         _v = 0;
       } else {
         _v = 1;
@@ -5379,13 +6654,20 @@ static int _wrap_Session_ready(lua_State* L) {
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   bool result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_ready");
+  SWIG_check_num_args("ready",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ready",1,"LUA::Session *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_ready",1,SWIGTYPE_p_LUA__Session);
+  }
+  
   result = (bool)(arg1)->ready();
   SWIG_arg=0;
-  lua_pushboolean(L,(int)result); SWIG_arg++;
+  lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5400,19 +6682,30 @@ static int _wrap_Session_originate(lua_State* L) {
   int arg4 ;
   int result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  if(!lua_isstring(L,3)) SWIG_fail_arg(3);
-  if(!lua_isnumber(L,4)) SWIG_fail_arg(4);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_originate");
-  arg2=(CoreSession *)SWIG_MustGetPtr(L,2,SWIGTYPE_p_CoreSession,0,2,"Session_originate");
-  arg3 = (char*)lua_tostring(L, 3);
+  SWIG_check_num_args("originate",4,4)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("originate",1,"LUA::Session *");
+  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("originate",2,"CoreSession *");
+  if(!lua_isstring(L,3)) SWIG_fail_arg("originate",3,"char *");
+  if(!lua_isnumber(L,4)) SWIG_fail_arg("originate",4,"int");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_originate",1,SWIGTYPE_p_LUA__Session);
+  }
+  
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_CoreSession,0))){
+    SWIG_fail_ptr("Session_originate",2,SWIGTYPE_p_CoreSession);
+  }
+  
+  arg3 = (char *)lua_tostring(L, 3);
   arg4 = (int)lua_tonumber(L, 4);
   result = (int)(arg1)->originate(arg2,arg3,arg4);
   SWIG_arg=0;
   lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5424,15 +6717,20 @@ static int _wrap_Session_cb_function_set(lua_State* L) {
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   char *arg2 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_cb_function_set");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("cb_function",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("cb_function",1,"LUA::Session *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("cb_function",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_cb_function_set",1,SWIGTYPE_p_LUA__Session);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   {
     if (arg1->cb_function) delete [] arg1->cb_function;
     if (arg2) {
-      arg1->cb_function = (char *) (new char[strlen(arg2)+1]);
-      strcpy((char *) arg1->cb_function,arg2);
+      arg1->cb_function = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->cb_function, (const char *)arg2);
     } else {
       arg1->cb_function = 0;
     }
@@ -5441,6 +6739,8 @@ static int _wrap_Session_cb_function_set(lua_State* L) {
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5452,13 +6752,20 @@ static int _wrap_Session_cb_function_get(lua_State* L) {
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_cb_function_get");
+  SWIG_check_num_args("cb_function",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("cb_function",1,"LUA::Session *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_cb_function_get",1,SWIGTYPE_p_LUA__Session);
+  }
+  
   result = (char *) ((arg1)->cb_function);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5470,15 +6777,20 @@ static int _wrap_Session_cb_arg_set(lua_State* L) {
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   char *arg2 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_cb_arg_set");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("cb_arg",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("cb_arg",1,"LUA::Session *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("cb_arg",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_cb_arg_set",1,SWIGTYPE_p_LUA__Session);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   {
     if (arg1->cb_arg) delete [] arg1->cb_arg;
     if (arg2) {
-      arg1->cb_arg = (char *) (new char[strlen(arg2)+1]);
-      strcpy((char *) arg1->cb_arg,arg2);
+      arg1->cb_arg = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->cb_arg, (const char *)arg2);
     } else {
       arg1->cb_arg = 0;
     }
@@ -5487,6 +6799,8 @@ static int _wrap_Session_cb_arg_set(lua_State* L) {
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5498,13 +6812,20 @@ static int _wrap_Session_cb_arg_get(lua_State* L) {
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_cb_arg_get");
+  SWIG_check_num_args("cb_arg",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("cb_arg",1,"LUA::Session *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_cb_arg_get",1,SWIGTYPE_p_LUA__Session);
+  }
+  
   result = (char *) ((arg1)->cb_arg);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5516,15 +6837,20 @@ static int _wrap_Session_hangup_func_str_set(lua_State* L) {
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   char *arg2 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_hangup_func_str_set");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("hangup_func_str",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("hangup_func_str",1,"LUA::Session *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("hangup_func_str",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_hangup_func_str_set",1,SWIGTYPE_p_LUA__Session);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   {
     if (arg1->hangup_func_str) delete [] arg1->hangup_func_str;
     if (arg2) {
-      arg1->hangup_func_str = (char *) (new char[strlen(arg2)+1]);
-      strcpy((char *) arg1->hangup_func_str,arg2);
+      arg1->hangup_func_str = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->hangup_func_str, (const char *)arg2);
     } else {
       arg1->hangup_func_str = 0;
     }
@@ -5533,6 +6859,8 @@ static int _wrap_Session_hangup_func_str_set(lua_State* L) {
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5544,13 +6872,20 @@ static int _wrap_Session_hangup_func_str_get(lua_State* L) {
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_hangup_func_str_get");
+  SWIG_check_num_args("hangup_func_str",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("hangup_func_str",1,"LUA::Session *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_hangup_func_str_get",1,SWIGTYPE_p_LUA__Session);
+  }
+  
   result = (char *) ((arg1)->hangup_func_str);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5562,15 +6897,20 @@ static int _wrap_Session_hangup_func_arg_set(lua_State* L) {
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   char *arg2 = (char *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_hangup_func_arg_set");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("hangup_func_arg",2,2)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("hangup_func_arg",1,"LUA::Session *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("hangup_func_arg",2,"char *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_hangup_func_arg_set",1,SWIGTYPE_p_LUA__Session);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   {
     if (arg1->hangup_func_arg) delete [] arg1->hangup_func_arg;
     if (arg2) {
-      arg1->hangup_func_arg = (char *) (new char[strlen(arg2)+1]);
-      strcpy((char *) arg1->hangup_func_arg,arg2);
+      arg1->hangup_func_arg = (char *) (new char[strlen((const char *)arg2)+1]);
+      strcpy((char *)arg1->hangup_func_arg, (const char *)arg2);
     } else {
       arg1->hangup_func_arg = 0;
     }
@@ -5579,6 +6919,8 @@ static int _wrap_Session_hangup_func_arg_set(lua_State* L) {
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5590,13 +6932,20 @@ static int _wrap_Session_hangup_func_arg_get(lua_State* L) {
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   char *result = 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_hangup_func_arg_get");
+  SWIG_check_num_args("hangup_func_arg",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("hangup_func_arg",1,"LUA::Session *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_hangup_func_arg_get",1,SWIGTYPE_p_LUA__Session);
+  }
+  
   result = (char *) ((arg1)->hangup_func_arg);
   SWIG_arg=0;
-  lua_pushstring(L,result); SWIG_arg++;
+  lua_pushstring(L,(const char*)result); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5608,15 +6957,21 @@ static int _wrap_Session_setLUA(lua_State* L) {
   LUA::Session *arg1 = (LUA::Session *) 0 ;
   lua_State *arg2 = (lua_State *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isuserdata(L,2)) SWIG_fail_arg(2);
-  arg1=(LUA::Session *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Session,0,1,"Session_setLUA");
-  arg2=(lua_State *)SWIG_MustGetPtr(L,2,SWIGTYPE_p_lua_State,0,2,"Session_setLUA");
+  arg2 = L;
+  SWIG_check_num_args("setLUA",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("setLUA",1,"LUA::Session *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Session,0))){
+    SWIG_fail_ptr("Session_setLUA",1,SWIGTYPE_p_LUA__Session);
+  }
+  
   (arg1)->setLUA(arg2);
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5642,14 +6997,15 @@ static swig_lua_method swig_LUA_Session_methods[] = {
     {0,0}
 };
 static swig_lua_attribute swig_LUA_Session_attributes[] = {
-    { "cb_function",_wrap_Session_cb_function_get, _wrap_Session_cb_function_set},
-    { "cb_arg",_wrap_Session_cb_arg_get, _wrap_Session_cb_arg_set},
-    { "hangup_func_str",_wrap_Session_hangup_func_str_get, _wrap_Session_hangup_func_str_set},
-    { "hangup_func_arg",_wrap_Session_hangup_func_arg_get, _wrap_Session_hangup_func_arg_set},
+    { "cb_function", _wrap_Session_cb_function_get, _wrap_Session_cb_function_set},
+    { "cb_arg", _wrap_Session_cb_arg_get, _wrap_Session_cb_arg_set},
+    { "hangup_func_str", _wrap_Session_hangup_func_str_get, _wrap_Session_hangup_func_str_set},
+    { "hangup_func_arg", _wrap_Session_hangup_func_arg_get, _wrap_Session_hangup_func_arg_set},
     {0,0,0}
 };
-static swig_lua_class *swig_LUA_Session_bases[] = {&_wrap_class_CoreSession,0};
-swig_lua_class _wrap_class_LUA_Session = { "Session", &SWIGTYPE_p_LUA__Session,_wrap_new_Session, swig_delete_Session, swig_LUA_Session_methods, swig_LUA_Session_attributes, swig_LUA_Session_bases };
+static swig_lua_class *swig_LUA_Session_bases[] = {0,0};
+static const char *swig_LUA_Session_base_names[] = {"CoreSession *",0};
+static swig_lua_class _wrap_class_LUA_Session = { "Session", &SWIGTYPE_p_LUA__Session,_wrap_new_Session, swig_delete_Session, swig_LUA_Session_methods, swig_LUA_Session_attributes, swig_LUA_Session_bases, swig_LUA_Session_base_names };
 
 static int _wrap_new_Dbh__SWIG_0(lua_State* L) {
   int SWIG_arg = -1;
@@ -5658,17 +7014,20 @@ static int _wrap_new_Dbh__SWIG_0(lua_State* L) {
   char *arg3 = (char *) 0 ;
   LUA::Dbh *result = 0 ;
   
-  if(!lua_isstring(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(!lua_isstring(L,3)) SWIG_fail_arg(3);
-  arg1 = (char*)lua_tostring(L, 1);
-  arg2 = (char*)lua_tostring(L, 2);
-  arg3 = (char*)lua_tostring(L, 3);
+  SWIG_check_num_args("LUA::Dbh",3,3)
+  if(!lua_isstring(L,1)) SWIG_fail_arg("LUA::Dbh",1,"char *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("LUA::Dbh",2,"char *");
+  if(!lua_isstring(L,3)) SWIG_fail_arg("LUA::Dbh",3,"char *");
+  arg1 = (char *)lua_tostring(L, 1);
+  arg2 = (char *)lua_tostring(L, 2);
+  arg3 = (char *)lua_tostring(L, 3);
   result = (LUA::Dbh *)new LUA::Dbh(arg1,arg2,arg3);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_LUA__Dbh,1); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5681,15 +7040,18 @@ static int _wrap_new_Dbh__SWIG_1(lua_State* L) {
   char *arg2 = (char *) 0 ;
   LUA::Dbh *result = 0 ;
   
-  if(!lua_isstring(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  arg1 = (char*)lua_tostring(L, 1);
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("LUA::Dbh",2,2)
+  if(!lua_isstring(L,1)) SWIG_fail_arg("LUA::Dbh",1,"char *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("LUA::Dbh",2,"char *");
+  arg1 = (char *)lua_tostring(L, 1);
+  arg2 = (char *)lua_tostring(L, 2);
   result = (LUA::Dbh *)new LUA::Dbh(arg1,arg2);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_LUA__Dbh,1); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5701,13 +7063,16 @@ static int _wrap_new_Dbh__SWIG_2(lua_State* L) {
   char *arg1 = (char *) 0 ;
   LUA::Dbh *result = 0 ;
   
-  if(!lua_isstring(L,1)) SWIG_fail_arg(1);
-  arg1 = (char*)lua_tostring(L, 1);
+  SWIG_check_num_args("LUA::Dbh",1,1)
+  if(!lua_isstring(L,1)) SWIG_fail_arg("LUA::Dbh",1,"char *");
+  arg1 = (char *)lua_tostring(L, 1);
   result = (LUA::Dbh *)new LUA::Dbh(arg1);
   SWIG_arg=0;
   SWIG_NewPointerObj(L,result,SWIGTYPE_p_LUA__Dbh,1); SWIG_arg++; 
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5773,14 +7138,21 @@ static int _wrap_delete_Dbh(lua_State* L) {
   int SWIG_arg = -1;
   LUA::Dbh *arg1 = (LUA::Dbh *) 0 ;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(LUA::Dbh *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Dbh,0,1,"delete_Dbh");
+  SWIG_check_num_args("LUA::~Dbh",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("LUA::~Dbh",1,"LUA::Dbh *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Dbh,SWIG_POINTER_DISOWN))){
+    SWIG_fail_ptr("delete_Dbh",1,SWIGTYPE_p_LUA__Dbh);
+  }
+  
   delete arg1;
   
   SWIG_arg=0;
   
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5792,13 +7164,20 @@ static int _wrap_Dbh_release(lua_State* L) {
   LUA::Dbh *arg1 = (LUA::Dbh *) 0 ;
   bool result;
   
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  arg1=(LUA::Dbh *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Dbh,0,1,"Dbh_release");
+  SWIG_check_num_args("release",1,1)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("release",1,"LUA::Dbh *");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Dbh,0))){
+    SWIG_fail_ptr("Dbh_release",1,SWIGTYPE_p_LUA__Dbh);
+  }
+  
   result = (bool)(arg1)->release();
   SWIG_arg=0;
-  lua_pushboolean(L,(int)result); SWIG_arg++;
+  lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5818,11 +7197,16 @@ static int _wrap_Dbh_query(lua_State* L) {
     };
     arg3 = default_swiglua_fn;
   }
-  if(!lua_isuserdata(L,1)) SWIG_fail_arg(1);
-  if(!lua_isstring(L,2)) SWIG_fail_arg(2);
-  if(lua_gettop(L)>=3 && !lua_isfunction(L,3)) SWIG_fail_arg(3);
-  arg1=(LUA::Dbh *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_LUA__Dbh,0,1,"Dbh_query");
-  arg2 = (char*)lua_tostring(L, 2);
+  SWIG_check_num_args("query",2,3)
+  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("query",1,"LUA::Dbh *");
+  if(!lua_isstring(L,2)) SWIG_fail_arg("query",2,"char *");
+  if(lua_gettop(L)>=3 && !lua_isfunction(L,3)) SWIG_fail_arg("query",3,"SWIGLUA_FN");
+  
+  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_LUA__Dbh,0))){
+    SWIG_fail_ptr("Dbh_query",1,SWIGTYPE_p_LUA__Dbh);
+  }
+  
+  arg2 = (char *)lua_tostring(L, 2);
   if(lua_gettop(L)>=3){
     {
       (&arg3)->L = L;
@@ -5831,9 +7215,11 @@ static int _wrap_Dbh_query(lua_State* L) {
   }
   result = (bool)(arg1)->query(arg2,arg3);
   SWIG_arg=0;
-  lua_pushboolean(L,(int)result); SWIG_arg++;
+  lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
   return SWIG_arg;
   
+  if(0) SWIG_fail;
+  
 fail:
   lua_error(L);
   return SWIG_arg;
@@ -5853,7 +7239,8 @@ static swig_lua_attribute swig_LUA_Dbh_attributes[] = {
     {0,0,0}
 };
 static swig_lua_class *swig_LUA_Dbh_bases[] = {0};
-swig_lua_class _wrap_class_LUA_Dbh = { "Dbh", &SWIGTYPE_p_LUA__Dbh,_wrap_new_Dbh, swig_delete_Dbh, swig_LUA_Dbh_methods, swig_LUA_Dbh_attributes, swig_LUA_Dbh_bases };
+static const char *swig_LUA_Dbh_base_names[] = {0};
+static swig_lua_class _wrap_class_LUA_Dbh = { "Dbh", &SWIGTYPE_p_LUA__Dbh,_wrap_new_Dbh, swig_delete_Dbh, swig_LUA_Dbh_methods, swig_LUA_Dbh_attributes, swig_LUA_Dbh_bases, swig_LUA_Dbh_base_names };
 
 #ifdef __cplusplus
 }
@@ -5862,167 +7249,12 @@ swig_lua_class _wrap_class_LUA_Dbh = { "Dbh", &SWIGTYPE_p_LUA__Dbh,_wrap_new_Dbh
 static const struct luaL_reg swig_commands[] = {
     { "consoleLog", _wrap_consoleLog},
     { "consoleCleanLog", _wrap_consoleCleanLog},
-    { "new_IVRMenu", _wrap_new_IVRMenu},
-    { "delete_IVRMenu", _wrap_delete_IVRMenu},
-    { "IVRMenu_bindAction", _wrap_IVRMenu_bindAction},
-    { "IVRMenu_execute", _wrap_IVRMenu_execute},
-    { "new_API", _wrap_new_API},
-    { "delete_API", _wrap_delete_API},
-    { "API_execute", _wrap_API_execute},
-    { "API_executeString", _wrap_API_executeString},
-    { "API_getTime", _wrap_API_getTime},
-    { "input_callback_state_t_function_set", _wrap_input_callback_state_t_function_set},
-    { "input_callback_state_t_function_get", _wrap_input_callback_state_t_function_get},
-    { "input_callback_state_t_threadState_set", _wrap_input_callback_state_t_threadState_set},
-    { "input_callback_state_t_threadState_get", _wrap_input_callback_state_t_threadState_get},
-    { "input_callback_state_t_extra_set", _wrap_input_callback_state_t_extra_set},
-    { "input_callback_state_t_extra_get", _wrap_input_callback_state_t_extra_get},
-    { "input_callback_state_t_funcargs_set", _wrap_input_callback_state_t_funcargs_set},
-    { "input_callback_state_t_funcargs_get", _wrap_input_callback_state_t_funcargs_get},
-    { "new_input_callback_state_t", _wrap_new_input_callback_state_t},
-    { "delete_input_callback_state_t", _wrap_delete_input_callback_state_t},
-    { "DTMF_digit_set", _wrap_DTMF_digit_set},
-    { "DTMF_digit_get", _wrap_DTMF_digit_get},
-    { "DTMF_duration_set", _wrap_DTMF_duration_set},
-    { "DTMF_duration_get", _wrap_DTMF_duration_get},
-    { "new_DTMF", _wrap_new_DTMF},
-    { "delete_DTMF", _wrap_delete_DTMF},
-    { "new_Stream",_wrap_new_Stream},
-    { "delete_Stream", _wrap_delete_Stream},
-    { "Stream_write", _wrap_Stream_write},
-    { "Stream_get_data", _wrap_Stream_get_data},
-    { "Event_event_set", _wrap_Event_event_set},
-    { "Event_event_get", _wrap_Event_event_get},
-    { "Event_serialized_string_set", _wrap_Event_serialized_string_set},
-    { "Event_serialized_string_get", _wrap_Event_serialized_string_get},
-    { "Event_mine_set", _wrap_Event_mine_set},
-    { "Event_mine_get", _wrap_Event_mine_get},
-    { "new_Event",_wrap_new_Event},
-    { "delete_Event", _wrap_delete_Event},
-    { "Event_serialize", _wrap_Event_serialize},
-    { "Event_setPriority", _wrap_Event_setPriority},
-    { "Event_getHeader", _wrap_Event_getHeader},
-    { "Event_getBody", _wrap_Event_getBody},
-    { "Event_getType", _wrap_Event_getType},
-    { "Event_addBody", _wrap_Event_addBody},
-    { "Event_addHeader", _wrap_Event_addHeader},
-    { "Event_delHeader", _wrap_Event_delHeader},
-    { "Event_fire", _wrap_Event_fire},
-    { "EventConsumer_events_set", _wrap_EventConsumer_events_set},
-    { "EventConsumer_events_get", _wrap_EventConsumer_events_get},
-    { "EventConsumer_e_event_id_set", _wrap_EventConsumer_e_event_id_set},
-    { "EventConsumer_e_event_id_get", _wrap_EventConsumer_e_event_id_get},
-    { "EventConsumer_e_callback_set", _wrap_EventConsumer_e_callback_set},
-    { "EventConsumer_e_callback_get", _wrap_EventConsumer_e_callback_get},
-    { "EventConsumer_e_subclass_name_set", _wrap_EventConsumer_e_subclass_name_set},
-    { "EventConsumer_e_subclass_name_get", _wrap_EventConsumer_e_subclass_name_get},
-    { "EventConsumer_e_cb_arg_set", _wrap_EventConsumer_e_cb_arg_set},
-    { "EventConsumer_e_cb_arg_get", _wrap_EventConsumer_e_cb_arg_get},
-    { "EventConsumer_enodes_set", _wrap_EventConsumer_enodes_set},
-    { "EventConsumer_enodes_get", _wrap_EventConsumer_enodes_get},
-    { "EventConsumer_node_index_set", _wrap_EventConsumer_node_index_set},
-    { "EventConsumer_node_index_get", _wrap_EventConsumer_node_index_get},
-    { "new_EventConsumer", _wrap_new_EventConsumer},
-    { "delete_EventConsumer", _wrap_delete_EventConsumer},
-    { "EventConsumer_bind", _wrap_EventConsumer_bind},
-    { "EventConsumer_pop", _wrap_EventConsumer_pop},
-    { "delete_CoreSession", _wrap_delete_CoreSession},
-    { "CoreSession_session_set", _wrap_CoreSession_session_set},
-    { "CoreSession_session_get", _wrap_CoreSession_session_get},
-    { "CoreSession_channel_set", _wrap_CoreSession_channel_set},
-    { "CoreSession_channel_get", _wrap_CoreSession_channel_get},
-    { "CoreSession_flags_set", _wrap_CoreSession_flags_set},
-    { "CoreSession_flags_get", _wrap_CoreSession_flags_get},
-    { "CoreSession_allocated_set", _wrap_CoreSession_allocated_set},
-    { "CoreSession_allocated_get", _wrap_CoreSession_allocated_get},
-    { "CoreSession_cb_state_set", _wrap_CoreSession_cb_state_set},
-    { "CoreSession_cb_state_get", _wrap_CoreSession_cb_state_get},
-    { "CoreSession_hook_state_set", _wrap_CoreSession_hook_state_set},
-    { "CoreSession_hook_state_get", _wrap_CoreSession_hook_state_get},
-    { "CoreSession_cause_set", _wrap_CoreSession_cause_set},
-    { "CoreSession_cause_get", _wrap_CoreSession_cause_get},
-    { "CoreSession_uuid_set", _wrap_CoreSession_uuid_set},
-    { "CoreSession_uuid_get", _wrap_CoreSession_uuid_get},
-    { "CoreSession_tts_name_set", _wrap_CoreSession_tts_name_set},
-    { "CoreSession_tts_name_get", _wrap_CoreSession_tts_name_get},
-    { "CoreSession_voice_name_set", _wrap_CoreSession_voice_name_set},
-    { "CoreSession_voice_name_get", _wrap_CoreSession_voice_name_get},
-    { "CoreSession_answer", _wrap_CoreSession_answer},
-    { "CoreSession_preAnswer", _wrap_CoreSession_preAnswer},
-    { "CoreSession_hangup", _wrap_CoreSession_hangup},
-    { "CoreSession_hangupState", _wrap_CoreSession_hangupState},
-    { "CoreSession_setVariable", _wrap_CoreSession_setVariable},
-    { "CoreSession_setPrivate", _wrap_CoreSession_setPrivate},
-    { "CoreSession_getPrivate", _wrap_CoreSession_getPrivate},
-    { "CoreSession_getVariable", _wrap_CoreSession_getVariable},
-    { "CoreSession_process_callback_result", _wrap_CoreSession_process_callback_result},
-    { "CoreSession_say", _wrap_CoreSession_say},
-    { "CoreSession_sayPhrase", _wrap_CoreSession_sayPhrase},
-    { "CoreSession_hangupCause", _wrap_CoreSession_hangupCause},
-    { "CoreSession_getState", _wrap_CoreSession_getState},
-    { "CoreSession_recordFile", _wrap_CoreSession_recordFile},
-    { "CoreSession_originate", _wrap_CoreSession_originate},
-    { "CoreSession_destroy", _wrap_CoreSession_destroy},
-    { "CoreSession_setDTMFCallback", _wrap_CoreSession_setDTMFCallback},
-    { "CoreSession_speak", _wrap_CoreSession_speak},
-    { "CoreSession_set_tts_parms", _wrap_CoreSession_set_tts_parms},
-    { "CoreSession_collectDigits",_wrap_CoreSession_collectDigits},
-    { "CoreSession_getDigits",_wrap_CoreSession_getDigits},
-    { "CoreSession_transfer", _wrap_CoreSession_transfer},
-    { "CoreSession_read", _wrap_CoreSession_read},
-    { "CoreSession_playAndGetDigits", _wrap_CoreSession_playAndGetDigits},
-    { "CoreSession_streamFile", _wrap_CoreSession_streamFile},
-    { "CoreSession_sleep", _wrap_CoreSession_sleep},
-    { "CoreSession_flushEvents", _wrap_CoreSession_flushEvents},
-    { "CoreSession_flushDigits", _wrap_CoreSession_flushDigits},
-    { "CoreSession_setAutoHangup", _wrap_CoreSession_setAutoHangup},
-    { "CoreSession_setHangupHook", _wrap_CoreSession_setHangupHook},
-    { "CoreSession_ready", _wrap_CoreSession_ready},
-    { "CoreSession_bridged", _wrap_CoreSession_bridged},
-    { "CoreSession_answered", _wrap_CoreSession_answered},
-    { "CoreSession_mediaReady", _wrap_CoreSession_mediaReady},
-    { "CoreSession_waitForAnswer", _wrap_CoreSession_waitForAnswer},
-    { "CoreSession_execute", _wrap_CoreSession_execute},
-    { "CoreSession_sendEvent", _wrap_CoreSession_sendEvent},
-    { "CoreSession_setEventData", _wrap_CoreSession_setEventData},
-    { "CoreSession_getXMLCDR", _wrap_CoreSession_getXMLCDR},
-    { "CoreSession_begin_allow_threads", _wrap_CoreSession_begin_allow_threads},
-    { "CoreSession_end_allow_threads", _wrap_CoreSession_end_allow_threads},
-    { "CoreSession_get_uuid", _wrap_CoreSession_get_uuid},
-    { "CoreSession_get_cb_args", _wrap_CoreSession_get_cb_args},
-    { "CoreSession_check_hangup_hook", _wrap_CoreSession_check_hangup_hook},
-    { "CoreSession_run_dtmf_callback", _wrap_CoreSession_run_dtmf_callback},
     { "console_log", _wrap_console_log},
     { "console_clean_log", _wrap_console_clean_log},
     { "msleep", _wrap_msleep},
     { "bridge", _wrap_bridge},
     { "hanguphook", _wrap_hanguphook},
     { "dtmf_callback", _wrap_dtmf_callback},
-    { "new_Session",_wrap_new_Session},
-    { "delete_Session", _wrap_delete_Session},
-    { "Session_destroy", _wrap_Session_destroy},
-    { "Session_begin_allow_threads", _wrap_Session_begin_allow_threads},
-    { "Session_end_allow_threads", _wrap_Session_end_allow_threads},
-    { "Session_check_hangup_hook", _wrap_Session_check_hangup_hook},
-    { "Session_run_dtmf_callback", _wrap_Session_run_dtmf_callback},
-    { "Session_unsetInputCallback", _wrap_Session_unsetInputCallback},
-    { "Session_setInputCallback",_wrap_Session_setInputCallback},
-    { "Session_setHangupHook",_wrap_Session_setHangupHook},
-    { "Session_ready", _wrap_Session_ready},
-    { "Session_originate", _wrap_Session_originate},
-    { "Session_cb_function_set", _wrap_Session_cb_function_set},
-    { "Session_cb_function_get", _wrap_Session_cb_function_get},
-    { "Session_cb_arg_set", _wrap_Session_cb_arg_set},
-    { "Session_cb_arg_get", _wrap_Session_cb_arg_get},
-    { "Session_hangup_func_str_set", _wrap_Session_hangup_func_str_set},
-    { "Session_hangup_func_str_get", _wrap_Session_hangup_func_str_get},
-    { "Session_hangup_func_arg_set", _wrap_Session_hangup_func_arg_set},
-    { "Session_hangup_func_arg_get", _wrap_Session_hangup_func_arg_get},
-    { "Session_setLUA", _wrap_Session_setLUA},
-    { "new_Dbh",_wrap_new_Dbh},
-    { "delete_Dbh", _wrap_delete_Dbh},
-    { "Dbh_release", _wrap_Dbh_release},
-    { "Dbh_query", _wrap_Dbh_query},
     {0,0}
 };
 
@@ -6039,10 +7271,9 @@ static swig_lua_const_info swig_constants[] = {
 
 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
 
-static void *_p_LUA__SessionTo_p_CoreSession(void *x) {
+static void *_p_LUA__SessionTo_p_CoreSession(void *x, int *newmemory) {
     return (void *)((CoreSession *)  ((LUA::Session *) x));
 }
-static swig_type_info _swigt__SWIGLUA_FN = {"_SWIGLUA_FN", "SWIGLUA_FN", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_API = {"_p_API", "API *", 0, 0, (void*)&_wrap_class_API, 0};
 static swig_type_info _swigt__p_CoreSession = {"_p_CoreSession", "CoreSession *", 0, 0, (void*)&_wrap_class_CoreSession, 0};
 static swig_type_info _swigt__p_DTMF = {"_p_DTMF", "DTMF *", 0, 0, (void*)&_wrap_class_DTMF, 0};
@@ -6051,8 +7282,9 @@ static swig_type_info _swigt__p_EventConsumer = {"_p_EventConsumer", "EventConsu
 static swig_type_info _swigt__p_IVRMenu = {"_p_IVRMenu", "IVRMenu *", 0, 0, (void*)&_wrap_class_IVRMenu, 0};
 static swig_type_info _swigt__p_LUA__Dbh = {"_p_LUA__Dbh", "LUA::Dbh *", 0, 0, (void*)&_wrap_class_LUA_Dbh, 0};
 static swig_type_info _swigt__p_LUA__Session = {"_p_LUA__Session", "LUA::Session *", 0, 0, (void*)&_wrap_class_LUA_Session, 0};
+static swig_type_info _swigt__p_SWIGLUA_FN = {"_p_SWIGLUA_FN", "SWIGLUA_FN *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Stream = {"_p_Stream", "Stream *", 0, 0, (void*)&_wrap_class_Stream, 0};
-static swig_type_info _swigt__p_input_callback_state = {"_p_input_callback_state", "input_callback_state *", 0, 0, (void*)&_wrap_class_input_callback_state_t, 0};
+static swig_type_info _swigt__p_input_callback_state = {"_p_input_callback_state", "input_callback_state_t *|input_callback_state *", 0, 0, (void*)&_wrap_class_input_callback_state_t, 0};
 static swig_type_info _swigt__p_lua_State = {"_p_lua_State", "lua_State *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_p_switch_event_node_t = {"_p_p_switch_event_node_t", "switch_event_node_t **", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_session_flag_t = {"_p_session_flag_t", "enum session_flag_t *|session_flag_t *", 0, 0, (void*)0, 0};
@@ -6071,15 +7303,8 @@ static swig_type_info _swigt__p_switch_status_t = {"_p_switch_status_t", "switch
 static swig_type_info _swigt__p_switch_stream_handle_t = {"_p_switch_stream_handle_t", "switch_stream_handle_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_uint32_t = {"_p_uint32_t", "uint32_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__switch_call_cause_t = {"_switch_call_cause_t", "switch_call_cause_t", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__switch_channel_state_t = {"_switch_channel_state_t", "switch_channel_state_t", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__switch_event_types_t = {"_switch_event_types_t", "switch_event_types_t", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__switch_input_type_t = {"_switch_input_type_t", "switch_input_type_t", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__switch_priority_t = {"_switch_priority_t", "switch_priority_t", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__uint32_t = {"_uint32_t", "uint32_t", 0, 0, (void*)0, 0};
 
 static swig_type_info *swig_type_initial[] = {
-  &_swigt__SWIGLUA_FN,
   &_swigt__p_API,
   &_swigt__p_CoreSession,
   &_swigt__p_DTMF,
@@ -6088,6 +7313,7 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_IVRMenu,
   &_swigt__p_LUA__Dbh,
   &_swigt__p_LUA__Session,
+  &_swigt__p_SWIGLUA_FN,
   &_swigt__p_Stream,
   &_swigt__p_input_callback_state,
   &_swigt__p_lua_State,
@@ -6108,15 +7334,8 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_switch_stream_handle_t,
   &_swigt__p_uint32_t,
   &_swigt__p_void,
-  &_swigt__switch_call_cause_t,
-  &_swigt__switch_channel_state_t,
-  &_swigt__switch_event_types_t,
-  &_swigt__switch_input_type_t,
-  &_swigt__switch_priority_t,
-  &_swigt__uint32_t,
 };
 
-static swig_cast_info _swigc__SWIGLUA_FN[] = {  {&_swigt__SWIGLUA_FN, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_API[] = {  {&_swigt__p_API, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_CoreSession[] = {  {&_swigt__p_CoreSession, 0, 0, 0},  {&_swigt__p_LUA__Session, _p_LUA__SessionTo_p_CoreSession, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_DTMF[] = {  {&_swigt__p_DTMF, 0, 0, 0},{0, 0, 0, 0}};
@@ -6125,6 +7344,7 @@ static swig_cast_info _swigc__p_EventConsumer[] = {  {&_swigt__p_EventConsumer,
 static swig_cast_info _swigc__p_IVRMenu[] = {  {&_swigt__p_IVRMenu, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_LUA__Dbh[] = {  {&_swigt__p_LUA__Dbh, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_LUA__Session[] = {  {&_swigt__p_LUA__Session, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_SWIGLUA_FN[] = {  {&_swigt__p_SWIGLUA_FN, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Stream[] = {  {&_swigt__p_Stream, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_input_callback_state[] = {  {&_swigt__p_input_callback_state, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_lua_State[] = {  {&_swigt__p_lua_State, 0, 0, 0},{0, 0, 0, 0}};
@@ -6145,15 +7365,8 @@ static swig_cast_info _swigc__p_switch_status_t[] = {  {&_swigt__p_switch_status
 static swig_cast_info _swigc__p_switch_stream_handle_t[] = {  {&_swigt__p_switch_stream_handle_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_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__switch_call_cause_t[] = {  {&_swigt__switch_call_cause_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__switch_channel_state_t[] = {  {&_swigt__switch_channel_state_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__switch_event_types_t[] = {  {&_swigt__switch_event_types_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__switch_input_type_t[] = {  {&_swigt__switch_input_type_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__switch_priority_t[] = {  {&_swigt__switch_priority_t, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__uint32_t[] = {  {&_swigt__uint32_t, 0, 0, 0},{0, 0, 0, 0}};
 
 static swig_cast_info *swig_cast_initial[] = {
-  _swigc__SWIGLUA_FN,
   _swigc__p_API,
   _swigc__p_CoreSession,
   _swigc__p_DTMF,
@@ -6162,6 +7375,7 @@ static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_IVRMenu,
   _swigc__p_LUA__Dbh,
   _swigc__p_LUA__Session,
+  _swigc__p_SWIGLUA_FN,
   _swigc__p_Stream,
   _swigc__p_input_callback_state,
   _swigc__p_lua_State,
@@ -6182,12 +7396,6 @@ static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_switch_stream_handle_t,
   _swigc__p_uint32_t,
   _swigc__p_void,
-  _swigc__switch_call_cause_t,
-  _swigc__switch_channel_state_t,
-  _swigc__switch_event_types_t,
-  _swigc__switch_input_type_t,
-  _swigc__switch_priority_t,
-  _swigc__uint32_t,
 };
 
 
@@ -6207,7 +7415,7 @@ static swig_cast_info *swig_cast_initial[] = {
  * structures together.
  *
  * The generated swig_type_info structures are assigned staticly to an initial 
- * array. We just loop though that array, and handle each type individually.
+ * 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
@@ -6245,32 +7453,58 @@ extern "C" {
 #define SWIGRUNTIME_DEBUG
 #endif
 
+
 SWIGRUNTIME void
 SWIG_InitializeModule(void *clientdata) {
   size_t i;
-  swig_module_info *module_head;
-  static int init_run = 0;
+  swig_module_info *module_head, *iter;
+  int found, init;
 
   clientdata = clientdata;
 
-  if (init_run) return;
-  init_run = 1;
-
-  /* Initialize the swig_module */
-  swig_module.type_initial = swig_type_initial;
-  swig_module.cast_initial = swig_cast_initial;
+  /* 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) {
+  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);
+    module_head = &swig_module;
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    found=0;
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        found=1;
+        break;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* if the is found in the list, then all is done and we may leave */
+    if (found) return;
+    /* otherwise we must add out module into the list */
     swig_module.next = module_head->next;
     module_head->next = &swig_module;
-  } else {
-    /* This is the first module loaded */
-    swig_module.next = &swig_module;
-    SWIG_SetModule(clientdata, &swig_module);
   }
-                
+
+  /* When multiple interpeters 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);
@@ -6407,73 +7641,56 @@ SWIG_PropagateClientData(void) {
 
 
 /* Forward declaration of where the user's %init{} gets inserted */
+void SWIG_init_user(lua_State* L );
+    
 #ifdef __cplusplus
 extern "C" {
 #endif
-void SWIG_init_user(lua_State* L );
-
 /* this is the initialization function
-       added at the very end of the code
-       the function is always called SWIG_init, but an eariler #define will rename it
+  added at the very end of the code
+  the function is always called SWIG_init, but an eariler #define will rename it
 */
 SWIGEXPORT int SWIG_init(lua_State* L)
 {
-       int i;
-
-       /* start with global table */
-       lua_pushvalue(L,LUA_GLOBALSINDEX);
-
-       SWIG_InitializeModule((void*)L);
-       SWIG_PropagateClientData();
-
-       /* invoke user-specific initialization */
-       SWIG_init_user(L);
-
-       /* add a global fn */
-       SWIG_Lua_add_function(L,"swig_type",SWIG_Lua_type);
-       SWIG_Lua_add_function(L,"swig_equals",SWIG_Lua_equal);
-
-       /* begin the module (its a table with the same name as the module) */
-       SWIG_Lua_module_begin(L,SWIG_name);
-       /* add commands/functions */
-       for (i = 0; swig_commands[i].name; i++){
-               SWIG_Lua_module_add_function(L,swig_commands[i].name,swig_commands[i].func);
-       }
-       /*luaL_openlib(L,NULL,swig_commands,0);*/
-       /* all in one */
-       /*luaL_openlib(L,SWIG_name,swig_commands,0);*/
-       /* add variables */
-       for (i = 0; swig_variables[i].name; i++){
-               SWIG_Lua_module_add_variable(L,swig_variables[i].name,swig_variables[i].get,swig_variables[i].set);
-       }
-
-       /* additional registration structs & classes in lua: */
-       for (i = 0; swig_types[i]; i++){
-               if (swig_types[i]->clientdata){
-                       SWIG_Lua_class_register(L,(swig_lua_class*)(swig_types[i]->clientdata));
-               }
-       }
-
-       /* constants */
-       SWIG_Lua_InstallConstants(L,swig_constants);
-
-       /* end module */
-       /*SWIG_Lua_module_end(L);*/
-       lua_pop(L,1);  /* tidy stack (remove module table)*/
-       lua_pop(L,1);  /* tidy stack (remove global table)*/
-
-       return 1;
-}
-
-/* Lua 5.1 has a different name for importing libraries
-luaopen_XXX, where XXX is the name of the module (not capitalised)
-this function will allow Lua 5.1 to import correctly.
-There is a #define in the wrapper to rename 'SWIG_import' to the correct name
-*/
-
-SWIGEXPORT int SWIG_import(lua_State* L)
-{
-       return SWIG_init(L);
+  int i;
+  /* start with global table */
+  lua_pushvalue(L,LUA_GLOBALSINDEX);
+  /* SWIG's internal initalisation */
+  SWIG_InitializeModule((void*)L);
+  SWIG_PropagateClientData();
+  /* add a global fn */
+  SWIG_Lua_add_function(L,"swig_type",SWIG_Lua_type);
+  SWIG_Lua_add_function(L,"swig_equals",SWIG_Lua_equal);
+  /* begin the module (its a table with the same name as the module) */
+  SWIG_Lua_module_begin(L,SWIG_name);
+  /* add commands/functions */
+  for (i = 0; swig_commands[i].name; i++){
+    SWIG_Lua_module_add_function(L,swig_commands[i].name,swig_commands[i].func);
+  }
+  /* add variables */
+  for (i = 0; swig_variables[i].name; i++){
+    SWIG_Lua_module_add_variable(L,swig_variables[i].name,swig_variables[i].get,swig_variables[i].set);
+  }
+  /* set up base class pointers (the hierachy) */
+  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));
+    }
+  }
+  /* additional registration structs & classes in lua */
+  for (i = 0; swig_types[i]; i++){
+    if (swig_types[i]->clientdata){
+      SWIG_Lua_class_register(L,(swig_lua_class*)(swig_types[i]->clientdata));
+    }
+  }
+  /* constants */
+  SWIG_Lua_InstallConstants(L,swig_constants);
+  /* invoke user-specific initialization */
+  SWIG_init_user(L);
+  /* end module */
+  lua_pop(L,1);  /* tidy stack (remove module table)*/
+  lua_pop(L,1);  /* tidy stack (remove global table)*/
+  return 1;
 }
 
 #ifdef __cplusplus
@@ -6481,12 +7698,13 @@ SWIGEXPORT int SWIG_import(lua_State* L)
 #endif
 
 
-#ifdef __cplusplus
-extern "C"
-#endif
+const char* SWIG_LUACODE=
+  "";
+
 void SWIG_init_user(lua_State* L)
 {
-  
+  /* exec Lua code if applicable */
+  SWIG_Lua_dostring(L,SWIG_LUACODE);
 }
 
 #include "mod_lua_extra.c"