Merge Lua changes - branch 'class_p1' of github.com:v-for-vandal/swig into v-for-vandal-class_p1

* 'class_p1' of github.com:v-for-vandal/swig:
  Fixing registerClass. No more wrap: unnecessary attributes
  Fixed registerMethod to work like registerVariable
  Switched to Swig_name_* functions
  Return MIN_OPT_LEVEL for elua
  add nspace_extend test case
  updated documentation following comd options renaming
  Options in alphabetical order
  Members renaming
  target_name -> lua_name
  Fixing cmd options, again
  Fixing segfault
  Removed class_parent_nspace
  Fixes to module options
  Rename methods to make it clear what 'symbols table' they operate on.
  Small documenation fixes
  Updating Lua documentation
  Eliminating namespaces_hash and using symbols table instead
  Attempt to catch unreproducable bug from Travis CI build
  Small bugfixes
  Bugfixes for eLua. eLua emulation mode
  Add compatibility option for old-style inheritance
  Add support for C-style enums in C mode. And tests.
  Style fixes. Comments fixes. Fixing cmd options. etc
  Some fixes for elua
  Attempt to fix unreproducable bug (from Travis CI build)
  Fixes for examples. Wrapped keywords into guardian in keyword_rename test
  Remove some typos
  Remove some obsolete code
  Manually beautifying luarun.swg
  Code beautifier
  Valuewrapper test
  Removing obsolete debug code
  Bugfixes
  A few bugfixes
  Some class bases iteration improvements
  Fixes for elua
  Bugfixes
  Bugfixes. CMD args handling. Code cleanup
  Bugfixes
  Preparations before pull request - part 1
  More changes. Mostly to the would-be class library
  Fixing issuse with v2-compatible static function names
  Add pointer guard
  Add runtime test
  Bugfixes
  nspace.i example is working
  Initial implementation - everything compiles but might not work

3 files changed, 867 insertions, 322 deletions

diff --git a/Lib/lua/lua.swg b/Lib/lua/lua.swg
index ee83d11b7..40087236b 100644
--- a/Lib/lua/lua.swg
+++ b/Lib/lua/lua.swg
@@ -41,12 +41,12 @@
 %typemap(consttab) long long, unsigned long long
        {SWIG_LUA_CONSTTAB_STRING("$symname", "$value")}
 
-%typemap(consttab) SWIGTYPE *, SWIGTYPE *const, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE []
-       { SWIG_LUA_POINTER, (char *)"$symname", 0, 0, (void *)$value, &$1_descriptor}
+%typemap(consttab) SWIGTYPE *, SWIGTYPE *const, SWIGTYPE &, SWIGTYPE []
+       { SWIG_LUA_CONSTTAB_POINTER("$symname",$value, $1_descriptor) }
 
 // member function pointers
 %typemap(consttab) SWIGTYPE (CLASS::*)
-       { SWIG_LUA_BINARY,  (char *)"$symname", sizeof($type), 0, (void *)&$value, &$1_descriptor}
+       { SWIG_LUA_CONSTTAB_BINARY("$symname", sizeof($type),&$value, $1_descriptor) }
 
 
 /* -----------------------------------------------------------------------------
diff --git a/Lib/lua/luarun.swg b/Lib/lua/luarun.swg
index 8485ed499..547231815 100644
--- a/Lib/lua/luarun.swg
+++ b/Lib/lua/luarun.swg
@@ -27,23 +27,110 @@ extern "C" {
 # error SWIG_LUA_TARGET not defined
 #endif
 
+#if defined(SWIG_LUA_ELUA_EMULATE)
+
+struct swig_elua_entry;
+
+typedef struct swig_elua_key {
+  int type;
+  union {
+    const char* strkey;
+    lua_Number numkey;
+  } key;
+} swig_elua_key;
+
+typedef struct swig_elua_val {
+  int type;
+  union {
+    lua_Number number;
+    const struct swig_elua_entry *table;
+    const char *string;
+    lua_CFunction function;
+    struct {
+      char member;
+      long lvalue;
+      void *pvalue;
+      swig_type_info **ptype;
+    } userdata;
+  } value;
+} swig_elua_val;
+
+typedef struct swig_elua_entry {
+  swig_elua_key key;
+  swig_elua_val value;
+} swig_elua_entry;
+
+#define LSTRKEY(x) {LUA_TSTRING, {.strkey = x} }
+#define LNUMKEY(x) {LUA_TNUMBER, {.numkey = x} }
+#define LNILKEY {LUA_TNIL, {.strkey = 0} }
+
+#define LNUMVAL(x) {LUA_TNUMBER, {.number = x} }
+#define LFUNCVAL(x) {LUA_TFUNCTION, {.function = x} }
+#define LROVAL(x) {LUA_TTABLE, {.table = x} }
+#define LNILVAL {LUA_TNIL, {.string = 0} }
+#define LSTRVAL(x) {LUA_TSTRING, {.string = x} }
+
+#define LUA_REG_TYPE swig_elua_entry
+
+#define SWIG_LUA_ELUA_EMUL_METATABLE_KEY "__metatable"
+
+#define lua_pushrotable(L,p)\
+  lua_newtable(L);\
+  assert(p);\
+  SWIG_Lua_elua_emulate_register(L,(swig_elua_entry*)(p));
+
+#define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\
+  LSTRKEY(B), {LUA_TUSERDATA, { .userdata={0,0,(void*)(C),&D} } }
+
+#define SWIG_LUA_CONSTTAB_BINARY(B,S,C,D)\
+  LSTRKEY(B), {LUA_TUSERDATA, { .userdata={1,S,(void*)(C),&D} } }
+#endif
+
 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
 #  define SWIG_LUA_CONSTTAB_INT(B, C) LSTRKEY(B), LNUMVAL(C)
 #  define SWIG_LUA_CONSTTAB_FLOAT(B, C) LSTRKEY(B), LNUMVAL(C)
 #  define SWIG_LUA_CONSTTAB_STRING(B, C) LSTRKEY(B), LSTRVAL(C)
 #  define SWIG_LUA_CONSTTAB_CHAR(B, C) LSTRKEY(B), LNUMVAL(C)
+    /* Those two types of constants are not supported in elua */
+
+#ifndef SWIG_LUA_CONSTTAB_POINTER
+#warning eLua does not support pointers as constants. By default, nil will be used as value
+#define SWIG_LUA_CONSTTAB_POINTER(B,C,D) LSTRKEY(B), LNILVAL
+#endif
+
+#ifndef SWIG_LUA_CONSTTAB_BINARY
+#warning eLua does not support pointers to member as constants. By default, nil will be used as value
+#define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D) LSTRKEY(B), LNILVAL
+#endif
 #else /* SWIG_LUA_FLAVOR_LUA */
 #  define SWIG_LUA_CONSTTAB_INT(B, C) SWIG_LUA_INT, (char *)B, (long)C, 0, 0, 0
 #  define SWIG_LUA_CONSTTAB_FLOAT(B, C) SWIG_LUA_FLOAT, (char *)B, 0, (double)C, 0, 0
 #  define SWIG_LUA_CONSTTAB_STRING(B, C) SWIG_LUA_STRING, (char *)B, 0, 0, (void *)C, 0
 #  define SWIG_LUA_CONSTTAB_CHAR(B, C) SWIG_LUA_CHAR, (char *)B, (long)C, 0, 0, 0
+#  define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\
+       SWIG_LUA_POINTER, (char *)B, 0, 0, (void *)C, &D
+#  define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D)\
+       SWIG_LUA_BINARY,  (char *)B, S, 0, (void *)C, &D
 #endif
 
+#ifndef SWIG_LUA_ELUA_EMULATE
 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
 #  define LRO_STRVAL(v) {{.p = (char *) v}, LUA_TSTRING}
 #  define LSTRVAL LRO_STRVAL
 #endif
+#endif /* SWIG_LUA_ELUA_EMULATE*/
+
+#ifndef SWIG_LUA_ELUA_EMULATE
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
+
+#ifndef MIN_OPT_LEVEL
+#define MIN_OPT_LEVEL 2
+#endif
 
+#include "lrodefs.h"
+#include "lrotable.h"
+#endif
+#endif /* SWIG_LUA_ELUA_EMULATE*/
 /* -----------------------------------------------------------------------------
  * compatibility defines
  * ----------------------------------------------------------------------------- */
@@ -70,6 +157,23 @@ extern "C" {
 # define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX)
 #endif
 
+/* lua_absindex was introduced in Lua 5.2 */
+#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
+# define lua_absindex(L,i) ((i)>0 || (i) <= LUA_REGISTRYINDEX ? (i) : lua_gettop(L) + (i) + 1)
+#endif
+
+/* lua_rawsetp was introduced in Lua 5.2 */
+#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
+#define lua_rawsetp(L,index,ptr)\
+  lua_pushlightuserdata(L,(void*)(ptr));\
+  lua_insert(L,-2);\
+  lua_rawset(L,index);
+
+#define lua_rawgetp(L,index,ptr)\
+  lua_pushlightuserdata(L,(void*)(ptr));\
+  lua_rawget(L,index);
+
+#endif
 
 /* --------------------------------------------------------------------------
  * Helper functions for error handling
@@ -119,6 +223,12 @@ typedef struct {
   lua_CFunction set;
 } swig_lua_var_info;
 
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
+typedef const LUA_REG_TYPE swig_lua_method;
+typedef const LUA_REG_TYPE swig_lua_const_info;
+#else /* Normal lua */
+typedef luaL_Reg swig_lua_method;
+
 /* Constant information structure */
 typedef struct {
     int type;
@@ -129,10 +239,7 @@ typedef struct {
     swig_type_info **ptype;
 } swig_lua_const_info;
 
-typedef struct {
-  const char     *name;
-  lua_CFunction   method;
-} swig_lua_method;
+#endif
 
 typedef struct {
   const char     *name;
@@ -140,23 +247,28 @@ typedef struct {
   lua_CFunction   setmethod;
 } swig_lua_attribute;
 
-// Can be used to create namespaces. Currently used to
-// wrap class static methods/variables/constants
-typedef struct {
+
+struct swig_lua_class;
+/* Can be used to create namespaces. Currently used to wrap class static methods/variables/constants */
+typedef struct swig_lua_namespace {
   const char            *name;
   swig_lua_method       *ns_methods;
   swig_lua_attribute    *ns_attributes;
   swig_lua_const_info   *ns_constants;
+  struct swig_lua_class        **ns_classes;
+  struct swig_lua_namespace    **ns_namespaces;
 } swig_lua_namespace;
 
 typedef struct swig_lua_class {
-  const char    *name;
+  const char    *name; /* Name that this class has in Lua */
+  const char    *fqname; /* Fully qualified name - Scope + class name */
   swig_type_info   **type;
   lua_CFunction  constructor;
   void    (*destructor)(void *);
   swig_lua_method   *methods;
   swig_lua_attribute     *attributes;
-  swig_lua_namespace    cls_static;
+  swig_lua_namespace    *cls_static;
+  swig_lua_method   *metatable; // 0 for -eluac
   struct swig_lua_class **bases;
   const char **base_names;
 } swig_lua_class;
@@ -226,12 +338,12 @@ typedef struct {
 #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)))
+/*#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_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);
@@ -242,7 +354,7 @@ SWIG_Lua_GetModule(lua_State* L) {
 }
 
 SWIGRUNTIME void
-SWIG_Lua_SetModule(lua_State* L, swig_module_info *module) {
+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);
@@ -256,7 +368,7 @@ SWIG_Lua_SetModule(lua_State* L, swig_module_info *module) {
 /* this function is called when trying to set an immutable.
 default action is to print an error.
 This can removed with a compile flag SWIGLUA_IGNORE_SET_IMMUTABLE */
-SWIGINTERN int SWIG_Lua_set_immutable(lua_State* L)
+SWIGINTERN int SWIG_Lua_set_immutable(lua_State *L)
 {
 /*  there should be 1 param passed in: the new value */
 #ifndef SWIGLUA_IGNORE_SET_IMMUTABLE
@@ -266,170 +378,184 @@ SWIGINTERN int SWIG_Lua_set_immutable(lua_State* L)
     return 0;   /* should not return anything */
 }
 
-/* the module.get method used for getting linked data */
-SWIGINTERN int SWIG_Lua_module_get(lua_State* L)
+#ifdef SWIG_LUA_ELUA_EMULATE
+//#define report(...) printf(__VA_ARGS__) // TODO: REMOVE
+#define report(...) // TODO : REMOVE
+
+SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own);
+SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type);
+static int swig_lua_elua_emulate_unique_key;
+/* This is function that emulates eLua rotables behaviour. It loads rotable definition
+ * into the usual lua table.
+ */
+SWIGINTERN void SWIG_Lua_elua_emulate_register(lua_State *L, const swig_elua_entry *table)
 {
-/*  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 */
-#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
-  assert(lua_isrotable(L,1)); /* just in case */
-#else
-  assert(lua_istable(L,1)); /* default Lua action */
-#endif
-  lua_getmetatable(L,1);  /* get the metatable */
-#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
-  assert(lua_isrotable(L,-1));  /* just in case */
-#else
   assert(lua_istable(L,-1));
-#endif
-  SWIG_Lua_get_table(L,".get");  /* get the .get table */
-  lua_remove(L,3);  /* remove metatable */
-#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
-  if (lua_isrotable(L,-1))
-#else
-  if (lua_istable(L,-1))
-#endif
-  {
-    /* 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 */
+  int target_table = lua_gettop(L);
+  /* Get the registry where we put all parsed tables to avoid loops */
+  lua_rawgetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key);
+  if(lua_isnil(L,-1)) {
+    lua_pop(L,1);
+    lua_newtable(L);
+    lua_pushvalue(L,-1);
+    lua_rawsetp(L,LUA_REGISTRYINDEX,(void*)(&swig_lua_elua_emulate_unique_key));
   }
-  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
-*/
-  /* get the metatable */
-#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
-  assert(lua_isrotable(L,1));  /* just in case */
-#else
-  assert(lua_istable(L,1)); /* default Lua action */
-#endif
-  lua_getmetatable(L,1);  /* get the metatable */
-#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
-  assert(lua_isrotable(L,-1));  /* just in case */
-#else
-  assert(lua_istable(L,-1));
-#endif
-  SWIG_Lua_get_table(L,".set");  /* get the .set table */
-  lua_remove(L,4);  /* remove metatable */
-#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
-  if (lua_isrotable(L,-1))
-#else
-  if (lua_istable(L,-1))
-#endif
+  int parsed_tables_array = lua_gettop(L);
+  lua_pushvalue(L,target_table);
+  lua_rawsetp(L, parsed_tables_array, table);
+  int i;
+  int table_parsed = 0;
+  int pairs_start = lua_gettop(L);
+  static int tabs_count = 0; // TODO: REMOVE
+  for(i = 0;table[i].key.type != LUA_TNIL || table[i].value.type != LUA_TNIL;i++)
   {
-    /* 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;
+    /* TODO: REMOVE */
+    int j = 0;
+    for(j=0;j<tabs_count;j++) report("  ");
+    /* END OF REMOVE */
+
+    report("Registering %d", int(i)); // TODO: REMOVE
+    const swig_elua_entry *entry = table + i;
+    int is_metatable = 0;
+    switch(entry->key.type) {
+      case LUA_TSTRING:
+        lua_pushstring(L,entry->key.key.strkey);
+        report(" %s :", entry->key.key.strkey); // TODO: REMOVE
+        if(strcmp(entry->key.key.strkey, SWIG_LUA_ELUA_EMUL_METATABLE_KEY) == 0)
+          is_metatable = 1;
+        break;
+      case  LUA_TNUMBER:
+        lua_pushnumber(L,entry->key.key.numkey);
+        report(" %f :", (double)(entry->key.key.numkey)); // TODO: REMOVE
+        break;
+      case LUA_TNIL:
+        report(" nil :"); // TODO: REMOVE
+        lua_pushnil(L);
+        break;
+      default:
+        assert(0);
     }
-#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) 
-    else {
-      return 0; // Exits stoically if an invalid key is initialized.
+    switch(entry->value.type) {
+      case LUA_TSTRING:
+        lua_pushstring(L,entry->value.value.string);
+        report(" %s", entry->value.value.string); // TODO: REMOVE
+        break;
+      case  LUA_TNUMBER:
+        lua_pushnumber(L,entry->value.value.number);
+        report(" %f", (double)(entry->value.value.number)); // TODO: REMOVE
+        break;
+      case LUA_TFUNCTION:
+        report(" %p", (void*)(entry->value.value.function)); // TODO: REMOVE
+        lua_pushcfunction(L,entry->value.value.function);
+        break;
+      case LUA_TTABLE:
+        /* TODO: REMOVE */
+        report(" table"); 
+        tabs_count++;
+        /* END OF REMOVE */
+        lua_rawgetp(L,parsed_tables_array, entry->value.value.table);
+        table_parsed = !lua_isnil(L,-1);
+        if(!table_parsed) {
+          lua_pop(L,1); /*remove nil */
+          report("\n"); // TODO: REMOVE
+          lua_newtable(L);
+          SWIG_Lua_elua_emulate_register(L,entry->value.value.table);
+        } else {
+          report(" already parsed"); // TODO: REMOVE
+        }
+        if(is_metatable) {
+          report(" (registering metatable)"); // TODO: REMOVE
+          assert(lua_istable(L,-1));
+          lua_pushvalue(L,-1);
+          lua_setmetatable(L,target_table);
+        }
+
+        tabs_count--; /*TODO: REMOVE*/
+        break;
+      case LUA_TUSERDATA:
+        if(entry->value.value.userdata.member) 
+          SWIG_NewMemberObj(L,entry->value.value.userdata.pvalue,
+              entry->value.value.userdata.lvalue,
+              *(entry->value.value.userdata.ptype));
+        else 
+          SWIG_NewPointerObj(L,entry->value.value.userdata.pvalue,
+              *(entry->value.value.userdata.ptype),0);
+        break;
+      case LUA_TNIL:
+        report(" nil"); // TODO: REMOVE
+        lua_pushnil(L);
+        break;
+      default:
+        assert(0);
     }
-#endif
+    assert(lua_gettop(L) == pairs_start + 2);
+    lua_rawset(L,target_table);
+    report("\n"); // TODO: REMOVE
   }
-  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;
+  lua_pop(L,1); /* Removing parsed tables storage */
+  assert(lua_gettop(L) == target_table);
 }
 
-#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
-/* registering a module in lua. Pushes the module table on the stack. */
-SWIGINTERN void  SWIG_Lua_module_begin(lua_State* L,const char* name)
+SWIGINTERN void SWIG_Lua_elua_emulate_register_clear(lua_State *L)
 {
-  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 */
-#ifdef SWIG_LUA_MODULE_GLOBAL
-  /* If requested, install the module directly into the global namespace. */
-  lua_rawset(L,-3);        /* add module into parent */
-  SWIG_Lua_get_table(L,name);   /* get the table back out */
-#else
-  /* Do not install the module table as global name. The stack top has
-     the module table with the name below. We pop the top and replace
-     the name with it. */
-  lua_replace(L,-2);
-#endif
+  lua_pushnil(L);
+  lua_rawsetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key);
 }
 
-/* ending the register */
-SWIGINTERN void  SWIG_Lua_module_end(lua_State* L)
-{
-  lua_pop(L,1);       /* tidy stack (remove module) */
-}
+/* TODO: REMOVE */
+SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L);
 
-/* 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)
+SWIGINTERN int SWIG_Lua_emulate_elua_getmetatable(lua_State *L)
 {
-  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) */
+  SWIG_check_num_args("getmetatable(SWIG eLua emulation)", 1, 1);
+  SWIG_Lua_get_class_registry(L);
+  lua_getfield(L,-1,"lua_getmetatable");
+  lua_remove(L,-2); /* remove the registry*/
+  assert(!lua_isnil(L,-1));
+  lua_pushvalue(L,1);
+  assert(lua_gettop(L) == 3); /* object | function | object again */
+  lua_call(L,1,1);
+  if(!lua_isnil(L,-1)) /*There is an ordinary metatable */
+    return 1;
+  /*if it is a table, then emulate elua behaviour - check for __metatable attribute of a table*/
+  assert(lua_gettop(L) == 2);
+  if(lua_istable(L,-2)) {
+    printf("getmetatable: elua emulation part\n"); // TODO: REMOVE
+    lua_pop(L,1); /*remove the nil*/
+    lua_getfield(L,-1, SWIG_LUA_ELUA_EMUL_METATABLE_KEY);
   }
-  lua_pop(L,1);       /* tidy stack (remove meta) */
+  assert(lua_gettop(L) == 2);
+  return 1;
+  
+fail:
+  lua_error(L);
+  return 0;
 }
-#endif
 
-/* adding a function module */
-SWIGINTERN void  SWIG_Lua_module_add_function(lua_State* L,const char* name,lua_CFunction fn)
+SWIGINTERN void SWIG_Lua_emulate_elua_swap_getmetatable(lua_State *L)
 {
-  SWIG_Lua_add_function(L,name,fn);
+  int begin = lua_gettop(L); // TODO: REMOVE
+  SWIG_Lua_get_class_registry(L);
+  lua_pushglobaltable(L);
+  lua_pushstring(L,"lua_getmetatable");
+  lua_getfield(L,-2,"getmetatable");
+  assert(!lua_isnil(L,-1));
+  lua_rawset(L,-4);
+  lua_pushstring(L, "getmetatable");
+  lua_pushcfunction(L, SWIG_Lua_emulate_elua_getmetatable);
+  lua_rawset(L,-3);
+  lua_pop(L,2);
+  assert(lua_gettop(L) == begin); // TODO: REMOVE
+      
 }
+/* END OF REMOVE */
 
+#endif
 /* -----------------------------------------------------------------------------
- * global variable support code: namespaces
+ * global variable support code: namespaces and modules (which are the same thing)
  * ----------------------------------------------------------------------------- */
 
-SWIGINTERN int SWIG_Lua_namespace_get(lua_State* L)
+SWIGINTERN int SWIG_Lua_namespace_get(lua_State *L)
 {
 /*  there should be 2 params passed in
   (1) table (not the meta table)
@@ -466,7 +592,7 @@ SWIGINTERN int SWIG_Lua_namespace_get(lua_State* L)
   return 0;
 }
 
-SWIGINTERN int SWIG_Lua_namespace_set(lua_State* L)
+SWIGINTERN int SWIG_Lua_namespace_set(lua_State *L)
 {
 /*  there should be 3 params passed in
   (1) table (not the meta table)
@@ -493,46 +619,69 @@ SWIGINTERN int SWIG_Lua_namespace_set(lua_State* L)
     lua_pop(L,1);  /* remove the value */
   }
   lua_pop(L,1);  /* remove the value .set table */
+  lua_pop(L,1); /* remote metatable */
+  assert(lua_gettop(L) == 3); // TODO: REMOVE
+  lua_rawset(L,-3);
   return 0;
 }
 
-SWIGINTERN void SWIG_Lua_InstallConstants(lua_State* L, swig_lua_const_info constants[]); // forward declaration
-SWIGINTERN void  SWIG_Lua_add_class_variable(lua_State* L,const char* name,lua_CFunction getFn,lua_CFunction setFn); // forward declaration
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */
+SWIGINTERN void SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]); /* forward declaration */
+SWIGINTERN void  SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn); /* forward declaration */
+SWIGINTERN void  SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss);
 
 /* helper function - register namespace methods and attributes into namespace */
-SWIGINTERN int SWIG_Lua_add_namespace_details(lua_State* L, swig_lua_namespace* ns)
+SWIGINTERN int SWIG_Lua_add_namespace_details(lua_State *L, swig_lua_namespace *ns)
 {
   int i = 0;
+  /* There must be namespace table (not metatable) at the top of the stack */
   assert(lua_istable(L,-1));
-  /* There must be table at the top of the stack */
   SWIG_Lua_InstallConstants(L, ns->ns_constants);
 
+  /* add methods to the namespace/module table */
+  for(i=0;ns->ns_methods[i].name;i++){
+    SWIG_Lua_add_function(L,ns->ns_methods[i].name,ns->ns_methods[i].func);
+  }
   lua_getmetatable(L,-1);
 
   /* add fns */
   for(i=0;ns->ns_attributes[i].name;i++){
-    SWIG_Lua_add_class_variable(L,ns->ns_attributes[i].name,ns->ns_attributes[i].getmethod,ns->ns_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;ns->ns_methods[i].name;i++){
-    SWIG_Lua_add_function(L,ns->ns_methods[i].name,ns->ns_methods[i].method);
+    SWIG_Lua_add_variable(L,ns->ns_attributes[i].name,ns->ns_attributes[i].getmethod,ns->ns_attributes[i].setmethod);
   }
-  lua_pop(L,1);
 
   /* clear stack - remove metatble */
   lua_pop(L,1);
   return 0;
 }
 
-/* helper function. creates namespace table and add it to module table */
-SWIGINTERN int SWIG_Lua_namespace_register(lua_State* L, swig_lua_namespace* ns)
+/* Register all classes in the namespace
+ */
+SWIGINTERN void SWIG_Lua_add_namespace_classes(lua_State *L, swig_lua_namespace *ns)
 {
-  assert(lua_istable(L,-1)); /* just in case. This is supposed to be module table */
+  /* There must be module/namespace table at the top of the stack */
+  assert(lua_istable(L,-1));
+
+  swig_lua_class **classes = ns->ns_classes;
+
+  if( classes != 0 ) {
+    while(*classes != 0) {
+      SWIG_Lua_class_register(L, *classes);
+      classes++;
+    }
+  }
+}
+
+/* helper function. creates namespace table and add it to module table
+   if 'reg' is true, then will register namespace table to parent one (must be on top of the stack
+   when function is called)
+   Function always returns newly registered table on top of the stack
+*/
+SWIGINTERN int SWIG_Lua_namespace_register(lua_State *L, swig_lua_namespace *ns, int reg)
+{
+  /* 1 argument - table on the top of the stack */
+  int begin = lua_gettop(L);
+  assert(lua_istable(L,-1)); /* just in case. This is supposed to be module table or parent namespace table */
   lua_checkstack(L,5);
-  lua_pushstring(L, ns->name);
   lua_newtable(L); /* namespace itself */
   lua_newtable(L); /* metatable for namespace */
 
@@ -554,47 +703,177 @@ SWIGINTERN int SWIG_Lua_namespace_register(lua_State* L, swig_lua_namespace* ns)
   SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_namespace_set);
 
   lua_setmetatable(L,-2); /* set metatable */
-  lua_rawset(L,-3); /* add namespace to module table */
-  return 0;
+
+  /* Register all functions, variables etc */
+  SWIG_Lua_add_namespace_details(L,ns);
+  /* Register classes */
+  SWIG_Lua_add_namespace_classes(L,ns);
+
+  swig_lua_namespace **sub_namespace = ns->ns_namespaces;
+  if( sub_namespace != 0) {
+    while(*sub_namespace != 0) {
+      SWIG_Lua_namespace_register(L, *sub_namespace, 1);
+      lua_pop(L,1); /* removing sub-namespace table */
+      sub_namespace++;
+    }
+  }
+
+  if (reg) {
+    lua_pushstring(L,ns->name);
+    lua_pushvalue(L,-2);
+    lua_rawset(L,-4); /* add namespace to module table */
+  }
+  assert(lua_gettop(L) == begin+1);
 }
+#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */
 /* -----------------------------------------------------------------------------
  * global variable support code: classes
  * ----------------------------------------------------------------------------- */
 
-/* the class.get method, performs the lookup of class attributes */
-SWIGINTERN int  SWIG_Lua_class_get(lua_State* L)
+SWIGINTERN void  SWIG_Lua_get_class_metatable(lua_State *L,const char *cname);
+
+/* Macroses for iteration among class bases */
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
+#define SWIG_LUA_INIT_BASE_SEARCH(bases_count)\
+  SWIG_Lua_get_table(L,".bases");\
+  assert(lua_istable(L,-1));\
+  bases_count = lua_rawlen(L,-1);\
+  int bases_table = lua_gettop(L);
+#define SWIG_LUA_GET_BASE_METATABLE(i,base_swig_type, valid)\
+  lua_rawgeti(L,bases_table,i+1);\
+  base_swig_type = 0;\
+  if(lua_isnil(L,-1)) {\
+    valid = 0;\
+    lua_pop(L,1);\
+  } else\
+    valid = 1;
+  
+#else /* en elua .bases table doesn't exist. Use table from swig_lua_class */
+
+#define SWIG_LUA_INIT_BASE_SEARCH(bases_count)\
+  assert(swig_type!=0);\
+  swig_module_info *module=SWIG_GetModule(L);\
+  swig_lua_class **bases= ((swig_lua_class*)(swig_type->clientdata))->bases;\
+  const char **base_names= ((swig_lua_class*)(swig_type->clientdata))->base_names;\
+  bases_count = 0;\
+  for(;base_names[bases_count];bases_count++);/* get length of bases */
+
+#define SWIG_LUA_GET_BASE_METATABLE(i,base_swig_type, valid)\
+  swig_lua_class *base_class = bases[i];\
+  if(!base_class)\
+    valid = 0;\
+  else {\
+    valid = 1;\
+    SWIG_Lua_get_class_metatable(L,base_class->fqname);\
+    base_swig_type = SWIG_TypeQueryModule(module,module,base_names[i]);\
+    assert(base_swig_type != 0);\
+  }
+
+#endif
+
+typedef int (*swig_lua_base_iterator_func)(lua_State*,swig_type_info*, int, int *ret);
+
+SWIGINTERN int SWIG_Lua_iterate_bases(lua_State *L, swig_type_info *swig_type, int first_arg, swig_lua_base_iterator_func func, int  *const ret)
+{
+    /* first_arg - position of the object in stack. Everything that is above are arguments
+     * and is passed to every evocation of the func */
+    int last_arg = lua_gettop(L);/* position of last argument */
+    lua_getmetatable(L,first_arg);
+    int original_metatable = last_arg + 1;
+    int bases_count;
+    SWIG_LUA_INIT_BASE_SEARCH(bases_count);
+    int result = SWIG_ERROR;
+    if(ret) *ret = 0;
+    if(bases_count>0)
+    {
+      int i;
+      int j;
+      int subcall_first_arg = lua_gettop(L) + 1;/* Here a copy of first_arg and arguments begin */
+      int valid = 1;
+      for(j=first_arg;j<=last_arg;j++)
+        lua_pushvalue(L,j);
+      int subcall_last_arg = lua_gettop(L);
+      swig_type_info *base_swig_type = 0;
+
+      /* Trick: temporaly replacing original metatable
+       * with metatable for base class and call getter */
+      for(i=0;i<bases_count;i++) {
+        SWIG_LUA_GET_BASE_METATABLE(i,base_swig_type,valid);
+        if(!valid)
+          continue;
+        assert(lua_isuserdata(L, subcall_first_arg));
+        assert(lua_istable(L,-1));
+        lua_setmetatable(L,subcall_first_arg); /* Set new metatable */
+        assert(lua_gettop(L) == subcall_last_arg);
+        result = func(L, base_swig_type,subcall_first_arg, ret); /* Forward call */
+        if(ret) assert(lua_gettop(L) == subcall_last_arg + *ret); // TODO: REMOVE 
+        if(result != SWIG_ERROR) {
+          break;
+        }
+      }
+      /* Return original metatable back */
+      lua_pushvalue(L,original_metatable);
+      lua_setmetatable(L,first_arg);
+      /* Clear - remove everything between last_arg and subcall_last_arg including */
+      const int to_remove = subcall_last_arg - last_arg;
+      for(j=0;j<to_remove;j++)
+        lua_remove(L,last_arg+1);
+      if(ret) assert(lua_gettop(L) == last_arg + *ret); // TODO: REMOVE
+    } else {
+      /* Remove everything after last_arg */
+      lua_pop(L, lua_gettop(L) - last_arg);
+    }
+    if(ret) assert(lua_gettop(L) == last_arg + *ret);
+    return result;
+}
+
+/* the class.get method helper, performs the lookup of class attributes
+ * It returns error code. Number of function return values is passed inside 'ret'
+ * first_arg is not used in this function because function always has 2 arguments.
+ */
+SWIGINTERN int  SWIG_Lua_class_do_get(lua_State *L, swig_type_info *type, int first_arg, int *ret)
 {
 /*  there should be 2 params passed in
   (1) userdata (not the meta table)
   (2) string name of the attribute
 */
+  int substack_start = lua_gettop(L)-2;
+  assert(first_arg == substack_start+1);
+  lua_checkstack(L,5);
   assert(lua_isuserdata(L,-2));  /* just in case */
   lua_getmetatable(L,-2);    /* get the meta table */
   assert(lua_istable(L,-1));  /* just in case */
+  // TODO: REMOVE
+  //SWIG_Lua_get_table(L,".type");
+  //printf("class %s get %s\n", lua_tostring(L,-1), lua_tostring(L,substack_start+2));
+  //lua_pop(L,1);
+  // END OF REMOVE
   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_pushvalue(L,substack_start+2);  /* key */
   lua_rawget(L,-2);
   lua_remove(L,-2); /* stack tidy, remove .get table */
   if (lua_iscfunction(L,-1))
   {  /* found it so call the fn & return its value */
-    lua_pushvalue(L,1);  /* the userdata */
+    lua_pushvalue(L,substack_start+1);  /* the userdata */
     lua_call(L,1,1);  /* 1 value in (userdata),1 out (result) */
     lua_remove(L,-2); /* stack tidy, remove metatable */
-    return 1;
+    if(ret) *ret = 1;
+    return SWIG_OK;
   }
   lua_pop(L,1);  /* remove whatever was there */
   /* ok, so try the .fn table */
-  SWIG_Lua_get_table(L,".fn"); /* find the .get table */
+  SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
   assert(lua_istable(L,-1));  /* just in case */
-  lua_pushvalue(L,2);  /* key */
+  lua_pushvalue(L,substack_start+2);  /* key */
   lua_rawget(L,-2);  /* look for the fn */
   lua_remove(L,-2); /* stack tidy, remove .fn table */
   if (lua_isfunction(L,-1)) /* note: if its a C function or lua function */
   {  /* found it so return the fn & let lua call it */
     lua_remove(L,-2); /* stack tidy, remove metatable */
-    return 1;
+    if(ret) *ret = 1;
+    return SWIG_OK;
   }
   lua_pop(L,1);  /* remove whatever was there */
   /* NEW: looks for the __getitem() fn
@@ -602,69 +881,150 @@ SWIGINTERN int  SWIG_Lua_class_get(lua_State* L)
   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_pushvalue(L,substack_start+1);  /* the userdata */
+    lua_pushvalue(L,substack_start+2);  /* the parameter */
     lua_call(L,2,1);  /* 2 value in (userdata),1 out (result) */
     lua_remove(L,-2); /* stack tidy, remove metatable */
-    return 1;
+    if(ret) *ret = 1;
+    return SWIG_OK;
   }
-  return 0;  /* sorry not known */
+  lua_pop(L,1);
+  /* Remove the metatable */
+  lua_pop(L,1);
+  /* Search in base classes */
+  assert(lua_gettop(L) == substack_start + 2); // TODO: REMOVE
+  
+  /* TODO: REMOVE
+#ifdef SWIG_LUA_SQUASH_BASES
+  if(ret) *ret = 0;
+  return SWIG_ERROR; // TODO:ERROR:FIX:REMOVE!!!!
+//#warning REMOVE REMOVE REMOVE
+#endif
+  END OF REMOVE */
+
+  //printf("failed, searching bases\n"); // TODO: REMOVE
+  int bases_search_result = SWIG_Lua_iterate_bases(L,type,substack_start+1,SWIG_Lua_class_do_get,ret);
+  if(ret) assert(lua_gettop(L) == substack_start + 2 + *ret); // TODO: REMOVE
+  // TODO: REMOVE
+  if(bases_search_result != SWIG_OK) {
+    //printf("failed.\n"); 
+  }
+  // END OF REMOVE
+  return bases_search_result;  /* sorry not known */
+}
+
+/* the class.get method, performs the lookup of class attributes
+ */
+SWIGINTERN int  SWIG_Lua_class_get(lua_State *L)
+{
+/*  there should be 2 params passed in
+  (1) userdata (not the meta table)
+  (2) string name of the attribute
+*/
+  assert(lua_isuserdata(L,1));
+  swig_lua_userdata *usr=(swig_lua_userdata*)lua_touserdata(L,1);  /* get data */
+  swig_type_info *type = usr->type;
+  int ret = 0;
+  int result = SWIG_Lua_class_do_get(L,type,1,&ret);
+  if(result == SWIG_OK)
+    return ret;
+
+  return 0;
 }
 
-/* the class.set method, performs the lookup of class attributes */
-SWIGINTERN int  SWIG_Lua_class_set(lua_State* L)
+/* helper for the class.set method, performs the lookup of class attributes
+ * It returns error code. Number of function return values is passed inside 'ret'
+ */
+SWIGINTERN int  SWIG_Lua_class_do_set(lua_State *L, swig_type_info *type, int first_arg, int *ret)
 {
 /*  there should be 3 params passed in
   (1) table (not the meta table)
   (2) string name of the attribute
   (3) any for the new value
-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 */
+  int substack_start = lua_gettop(L) - 3;
+  lua_checkstack(L,5);
+  assert(lua_isuserdata(L,substack_start+1));  /* just in case */
+  lua_getmetatable(L,substack_start+1);    /* get the meta table */
   assert(lua_istable(L,-1));  /* just in case */
+  if(ret) *ret = 0; /* it is setter - number of return values is always 0 */
 
   SWIG_Lua_get_table(L,".set"); /* find the .set table */
   if (lua_istable(L,-1))
   {
     /* look for the key in the .set table */
-    lua_pushvalue(L,2);  /* key */
+    lua_pushvalue(L,substack_start+2);  /* key */
     lua_rawget(L,-2);
+    lua_remove(L,-2); /* tidy stack, remove .set table */
     if (lua_iscfunction(L,-1))
     {  /* found it so call the fn & return its value */
-      lua_pushvalue(L,1);  /* userdata */
-      lua_pushvalue(L,3);  /* value */
+      lua_pushvalue(L,substack_start+1);  /* userdata */
+      lua_pushvalue(L,substack_start+3);  /* value */
       lua_call(L,2,0);
-      return 0;
+      lua_remove(L,substack_start+4); /*remove metatable*/
+      return SWIG_OK;
     }
     lua_pop(L,1);  /* remove the value */
+  } else {
+    lua_pop(L,1);  /* remove the answer for .set table request*/
   }
-  lua_pop(L,1);  /* remove the value .set table */
+  assert(lua_gettop(L) == substack_start + 4); // TODO: REMOVE
   /* 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_pushvalue(L,substack_start+1);  /* the userdata */
+    lua_pushvalue(L,substack_start+2);  /* the parameter */
+    lua_pushvalue(L,substack_start+3);  /* the value */
     lua_call(L,3,0);  /* 3 values in ,0 out */
     lua_remove(L,-2); /* stack tidy, remove metatable */
-    return 1;
+    return SWIG_OK;
+  }
+  lua_pop(L,1); /* remove value */
+  assert(lua_gettop(L) == substack_start + 4); // TODO: REMOVE
+
+  lua_pop(L,1); /* remove metatable */
+  /* Search among bases */
+  assert(lua_gettop(L) == first_arg+2); // TODO: REMOVE
+  int bases_search_result = SWIG_Lua_iterate_bases(L,type,first_arg,SWIG_Lua_class_do_set,ret);
+  if(ret) assert(*ret == 0);
+  assert(lua_gettop(L) == substack_start + 3);
+  return bases_search_result;
+}
+
+/* This is actuall method exported to Lua. It calls SWIG_Lua_class_do_set and correctly
+ * handlers return value
+ */
+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
+  */
+  assert(lua_isuserdata(L,1));
+  swig_lua_userdata *usr=(swig_lua_userdata*)lua_touserdata(L,1);  /* get data */
+  swig_type_info *type = usr->type;
+  int ret = 0;
+  int result = SWIG_Lua_class_do_set(L,type,1,&ret);
+  if(result != SWIG_OK) {
+   SWIG_Lua_pushferrstring(L,"Assignment not possible. No setter/member with this name. For custom assignments implement __setitem method");
+   lua_error(L);
+  } else {
+    assert(ret==0);
+    return 0;
   }
-  return 0;
 }
 
 /* the class.destruct method called by the interpreter */
-SWIGINTERN int  SWIG_Lua_class_destruct(lua_State* L)
+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;
+  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 */
@@ -680,7 +1040,7 @@ SWIGINTERN int  SWIG_Lua_class_destruct(lua_State* L)
 }
 
 /* the class.__tostring method called by the interpreter and print */
-SWIGINTERN int  SWIG_Lua_class_tostring(lua_State* L)
+SWIGINTERN int  SWIG_Lua_class_tostring(lua_State *L)
 {
 /*  there should be 1 param passed in
   (1) userdata (not the metatable) */
@@ -688,23 +1048,23 @@ SWIGINTERN int  SWIG_Lua_class_tostring(lua_State* L)
   unsigned long userData = (unsigned long)lua_touserdata(L,1); /* get the userdata address for later */
   lua_getmetatable(L,1);    /* get the meta table */
   assert(lua_istable(L,-1));  /* just in case */
-  
+
   lua_getfield(L, -1, ".type");
-  const char* className = lua_tostring(L, -1);
-  
+  const char *className = lua_tostring(L, -1);
+
   char output[256];
-  sprintf(output, "<%s userdata: %lX>", className, userData);
-  
+  snprintf(output, 255, "<%s userdata: %lX>", className, userData);
+
   lua_pushstring(L, (const char*)output);
   return 1;
 }
 
 /* to manually disown some userdata */
-SWIGINTERN int  SWIG_Lua_class_disown(lua_State* L)
+SWIGINTERN int  SWIG_Lua_class_disown(lua_State *L)
 {
 /*  there should be 1 params passed in
   (1) userdata (not the meta table) */
-  swig_lua_userdata* usr;
+  swig_lua_userdata *usr;
   assert(lua_isuserdata(L,-1));  /* just in case */
   usr=(swig_lua_userdata*)lua_touserdata(L,-1);  /* get it */
   
@@ -712,25 +1072,8 @@ SWIGINTERN int  SWIG_Lua_class_disown(lua_State* L)
   return 0;
 }
 
-/* Constructor proxy. Used when class name entry in module is not class constructor,
-but special table instead. */
-SWIGINTERN int SWIG_Lua_constructor_proxy(lua_State* L)
-{
-  /* unlimited number of parameters
-     First one is our proxy table and we should remove it
-     Other we should pass to real constructor
-   */
-   assert(lua_istable(L,1));
-   lua_pushstring(L,".constructor");
-   lua_rawget(L,1);
-   assert(!lua_isnil(L,-1));
-   lua_replace(L,1); /* replace our table with real constructor */
-   lua_call(L,lua_gettop(L)-1,1);
-   return 1;
-}
-
 /* gets the swig class registry (or creates it) */
-SWIGINTERN void  SWIG_Lua_get_class_registry(lua_State* L)
+SWIGINTERN void  SWIG_Lua_get_class_registry(lua_State *L)
 {
   /* add this all into the swig registry: */
   lua_pushstring(L,"SWIG");
@@ -748,7 +1091,7 @@ SWIGINTERN void  SWIG_Lua_get_class_registry(lua_State* L)
 }
 
 /* helper fn to get the classes metatable from the register */
-SWIGINTERN void  SWIG_Lua_get_class_metatable(lua_State* L,const char* cname)
+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 */
@@ -756,8 +1099,102 @@ SWIGINTERN void  SWIG_Lua_get_class_metatable(lua_State* L,const char* cname)
   lua_remove(L,-2);    /* tidy up (remove registry) */
 }
 
+/* set up the base classes pointers.
+Each class structure has a list of pointers to the base class structures.
+This function fills them.
+It cannot be done at compile time, as this will not work with hireachies
+spread over more than one swig file. 
+Therefore it must be done at runtime, querying the SWIG type system.
+*/
+SWIGINTERN void SWIG_Lua_init_base_class(lua_State *L,swig_lua_class *clss)
+{
+  int i=0;
+  swig_module_info *module=SWIG_GetModule(L);
+  for(i=0;clss->base_names[i];i++)
+  {
+    if (clss->bases[i]==0) /* not found yet */
+    {
+      /* lookup and cache the base class */
+      swig_type_info *info = SWIG_TypeQueryModule(module,module,clss->base_names[i]);
+      if (info) clss->bases[i] = (swig_lua_class *) info->clientdata;
+    }
+  }
+}
+
+#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
+/* Merges two tables  */
+SWIGINTERN int SWIG_Lua_merge_tables_by_index(lua_State *L, int target, int source)
+{
+  /* iterating */
+  lua_pushnil(L);
+  while (lua_next(L,source) != 0) {
+    /* -1 - value, -2 - index */
+    /* have to copy to assign */
+    lua_pushvalue(L,-2); /* copy of index */
+    lua_pushvalue(L,-2); /* copy of value */
+    lua_rawset(L, target);
+    lua_pop(L,1);
+    /* only key is left */
+  }
+}
+
+/* Merges two tables with given name. original - index of target metatable, base - index of source metatable */
+SWIGINTERN int SWIG_Lua_merge_tables(lua_State *L, const char* name, int original, int base)
+{
+  int begin = lua_gettop(L); // TODO:REMOVE
+  /* push original[name], then base[name] */
+  lua_pushstring(L,name);
+  lua_rawget(L,original);
+  int original_table = lua_gettop(L);
+  lua_pushstring(L,name);
+  lua_rawget(L,base);
+  int base_table = lua_gettop(L);
+  SWIG_Lua_merge_tables_by_index(L, original_table, base_table);
+  /* clearing stack */
+  lua_pop(L,2);
+  assert(lua_gettop(L) == begin); // TODO: REMOVE
+}
+
+/* Function takes all symbols from base and adds it to derived class. It's just a helper*/
+SWIGINTERN int  SWIG_Lua_class_squash_base(lua_State *L, swig_lua_class *base_cls)
+{
+  int begin = lua_gettop(L); // TODO:REMOVE
+  /* There is one parameter - original, i.e. 'derived' class metatable */
+  assert(lua_istable(L,-1));
+  int original = lua_gettop(L);
+  SWIG_Lua_get_class_metatable(L,base_cls->fqname);
+  int base = lua_gettop(L);
+  SWIG_Lua_merge_tables(L, ".fn", original, base );
+  SWIG_Lua_merge_tables(L, ".set", original, base );
+  SWIG_Lua_merge_tables(L, ".get", original, base );
+  lua_pop(L,1);
+  assert(lua_gettop(L) == begin); // TODO: REMOVE
+}
+
+/* Function squashes all symbols from 'clss' bases into itself */
+SWIGINTERN int  SWIG_Lua_class_squash_bases(lua_State *L, swig_lua_class *clss)
+{
+  int begin = lua_gettop(L); // TODO: REMOVE
+  int i;
+  SWIG_Lua_get_class_metatable(L,clss->fqname);
+  for(i=0;clss->base_names[i];i++)
+  {
+    if (clss->bases[i]==0) /* Somehow it's not found. Skip it */
+      continue;
+    /* Thing is: all bases are already registered. Thus they have already executed
+     * this function. So we just need to squash them into us, because their bases
+     * are already squashed into them. No need for recursion here!
+     */
+    SWIG_Lua_class_squash_base(L, clss->bases[i]);
+  }
+  lua_pop(L,1); /*tidy stack*/
+  assert(lua_gettop(L) == begin); // TODO: REMOVE
+}
+#endif
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */
 /* helper add a variable to a registered class */
-SWIGINTERN void  SWIG_Lua_add_class_variable(lua_State* L,const char* name,lua_CFunction getFn,lua_CFunction setFn)
+SWIGINTERN void  SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn)
 {
   assert(lua_istable(L,-1));  /* just in case */
   SWIG_Lua_get_table(L,".get"); /* find the .get table */
@@ -774,7 +1211,7 @@ SWIGINTERN void  SWIG_Lua_add_class_variable(lua_State* L,const char* name,lua_C
 }
 
 /* helper to recursively add class static details (static attributes, operations and constants) */
-SWIGINTERN void SWIG_Lua_add_class_static_details(lua_State* L, swig_lua_class* clss)
+SWIGINTERN void SWIG_Lua_add_class_static_details(lua_State *L, swig_lua_class *clss)
 {
   int i = 0;
   /* The class namespace table must be on the top of the stack */
@@ -785,72 +1222,60 @@ SWIGINTERN void SWIG_Lua_add_class_static_details(lua_State* L, swig_lua_class*
     SWIG_Lua_add_class_static_details(L,clss->bases[i]);
   }
 
-  SWIG_Lua_add_namespace_details(L, &clss->cls_static);
+  SWIG_Lua_add_namespace_details(L, clss->cls_static);
 }
 
 /* helper to recursively add class details (attributes & operations) */
-SWIGINTERN void  SWIG_Lua_add_class_details(lua_State* L,swig_lua_class* clss)
+SWIGINTERN void  SWIG_Lua_add_class_instance_details(lua_State *L,swig_lua_class *clss)
 {
   int i;
-  /* call all the base classes first: we can then override these later: */
+  /* Add bases to .bases table */
+  SWIG_Lua_get_table(L,".bases");
+  assert(lua_istable(L,-1));  /* just in case */
+  int bases_count = 0;
   for(i=0;clss->bases[i];i++)
   {
-    SWIG_Lua_add_class_details(L,clss->bases[i]);
+    SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname);
+    /* Base class must be already registered */
+    assert(lua_istable(L,-1));
+    lua_rawseti(L,-2,i+1); /* In lua indexing starts from 1 */
+    bases_count++;
   }
-  /* add fns */
+  assert(lua_rawlen(L,-1) == bases_count);
+  lua_pop(L,1); /* remove .bases table */
+  /* add attributes */
   for(i=0;clss->attributes[i].name;i++){
-    SWIG_Lua_add_class_variable(L,clss->attributes[i].name,clss->attributes[i].getmethod,clss->attributes[i].setmethod);
+    SWIG_Lua_add_variable(L,clss->attributes[i].name,clss->attributes[i].getmethod,clss->attributes[i].setmethod);
   }
   /* add methods to the metatable */
   SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
   assert(lua_istable(L,-1));  /* just in case */
   for(i=0;clss->methods[i].name;i++){
-    SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].method);
+    SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].func);
   }
   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;
+    This adds methods from metatable array to metatable. Can mess up garbage
+    collectind if someone defines __gc method
+    */
+  if(clss->metatable) {
+    for(i=0;clss->metatable[i].name;i++) {
+      assert(clss->metatable[i].func != 0); // TODO: REMOVE
+      SWIG_Lua_add_function(L,clss->metatable[i].name,clss->metatable[i].func);
     }
   }
 }
 
 /* Register class static methods,attributes etc as well as constructor proxy */
-SWIGINTERN void SWIG_Lua_class_register_static(lua_State* L, swig_lua_class* clss)
+SWIGINTERN void SWIG_Lua_class_register_static(lua_State *L, swig_lua_class *clss)
 {
+  int begin = lua_gettop(L);
   lua_checkstack(L,5); /* just in case */
   assert(lua_istable(L,-1));  /* just in case */
-  assert(strcmp(clss->name, clss->cls_static.name) == 0); /* in class those 2 must be equal */
+  assert(strcmp(clss->name, clss->cls_static->name) == 0); /* in class those 2 must be equal */
 
-  SWIG_Lua_namespace_register(L,&clss->cls_static);
+  SWIG_Lua_namespace_register(L,clss->cls_static, 1);
 
-  SWIG_Lua_get_table(L,clss->name); // Get namespace table back
   assert(lua_istable(L,-1)); /* just in case */
 
   /*  add its constructor to module with the name of the class
@@ -859,10 +1284,9 @@ SWIGINTERN void SWIG_Lua_class_register_static(lua_State* L, swig_lua_class* cls
   (this overcomes the problem of pure virtual classes without constructors)*/
   if (clss->constructor)
   {
-    SWIG_Lua_add_function(L,".constructor", clss->constructor);
     lua_getmetatable(L,-1);
     assert(lua_istable(L,-1)); /* just in case */
-    SWIG_Lua_add_function(L,"__call", SWIG_Lua_constructor_proxy);
+    SWIG_Lua_add_function(L,"__call", clss->constructor);
     lua_pop(L,1);
   }
 
@@ -871,19 +1295,59 @@ SWIGINTERN void SWIG_Lua_class_register_static(lua_State* L, swig_lua_class* cls
 
   /* clear stack */
   lua_pop(L,1);
+  assert( lua_gettop(L) == begin );
 }
 
-/* performs the entire class registration process */
-SWIGINTERN void  SWIG_Lua_class_register(lua_State* L,swig_lua_class* clss)
+/* performs the instance(non-static) class registration process. Metatable for class is created
+ * and added to the class registry.
+ */
+SWIGINTERN void  SWIG_Lua_class_register_instance(lua_State *L,swig_lua_class *clss)
 {
-  SWIG_Lua_class_register_static(L,clss);
-
+  int begin = lua_gettop(L);
+  /* if name already there (class is already registered) then do nothing */
   SWIG_Lua_get_class_registry(L);  /* get the registry */
-  lua_pushstring(L,clss->name);  /* get the name */
+  lua_pushstring(L,clss->fqname);  /* get the name */
+  lua_rawget(L,-2);
+  if(!lua_isnil(L,-1)) {
+    lua_pop(L,2);
+    assert(lua_gettop(L)==begin);
+    return;
+  }
+  lua_pop(L,2); /* tidy stack */
+  /* Recursively initialize all bases */
+  int i = 0;
+  for(i=0;clss->bases[i];i++)
+  {
+    SWIG_Lua_class_register_instance(L,clss->bases[i]);
+  }
+  /* Again, get registry and push name */
+  SWIG_Lua_get_class_registry(L);  /* get the registry */
+  lua_pushstring(L,clss->fqname);  /* get the name */
   lua_newtable(L);    /* create the metatable */
+#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
+  /* If squashing is requested, then merges all bases metatable into this one.
+   * It would get us all special methods: __getitem, __add etc.
+   * This would set .fn, .type, and other .xxx incorrectly, but we will overwrite it right away
+   */
+  int squash_begin = lua_gettop(L); // TODO:REMOVE
+  int new_metatable_index = lua_absindex(L,-1);
+  for(i=0;clss->bases[i];i++)
+  {
+    SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname);
+    int base_metatable = lua_absindex(L,-1);
+    SWIG_Lua_merge_tables_by_index(L,new_metatable_index, base_metatable);
+    lua_pop(L,1);
+  }
+  assert(lua_gettop(L) == squash_begin); // TODO: REMOVE
+  /* And now we will overwrite all incorrectly set data */
+#endif
   /* add string of class name called ".type" */
   lua_pushstring(L,".type");
-  lua_pushstring(L,clss->name);
+  lua_pushstring(L,clss->fqname);
+  lua_rawset(L,-3);
+  /* add a table called bases */
+  lua_pushstring(L,".bases");
+  lua_newtable(L);
   lua_rawset(L,-3);
   /* add a table called ".get" */
   lua_pushstring(L,".get");
@@ -908,22 +1372,95 @@ SWIGINTERN void  SWIG_Lua_class_register(lua_State* L,swig_lua_class* clss)
   /* add it */
   lua_rawset(L,-3);  /* metatable into registry */
   lua_pop(L,1);      /* tidy stack (remove registry) */
+  assert(lua_gettop(L)==begin);
 
-  SWIG_Lua_get_class_metatable(L,clss->name);
-  SWIG_Lua_add_class_details(L,clss);  /* recursive adding of details (atts & ops) */
+#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
+  /* Now merge all symbols from .fn, .set, .get etc from bases to our tables */
+  SWIG_Lua_class_squash_bases(L,clss);
+#endif
+  SWIG_Lua_get_class_metatable(L,clss->fqname);
+  SWIG_Lua_add_class_instance_details(L,clss);  /* recursive adding of details (atts & ops) */
   lua_pop(L,1);      /* tidy stack (remove class metatable) */
+  assert( lua_gettop(L) == begin );
+}
+
+SWIGINTERN void  SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss)
+{
+  assert(lua_istable(L,-1)); /* This is table(module or namespace) where class will be added */
+  SWIG_Lua_class_register_instance(L,clss);
+  SWIG_Lua_class_register_static(L,clss);
+
+  /* Add links from static part to instance part and vice versa */
+  /* [SWIG registry]                                   [Module]
+   *    "MyClass" ----> [MyClass metatable] <=====     "MyClass" -+> [static part]
+   *                     ".get" ----> ...        |                |     getmetatable()----|
+   *                     ".set" ----> ...        |                |                       |
+   *                     ".static" --------------)----------------/           [static part metatable]
+   *                                             |                                ".get" --> ...
+   *                                             |                                ".set" --> ....
+   *                                             |=============================== ".instance"
+   */
+  int begin = lua_gettop(L);
+  lua_pushstring(L,clss->cls_static->name);
+  lua_rawget(L,-2); /* get class static table */
+  assert(lua_istable(L,-1));
+  lua_getmetatable(L,-1);
+  assert(lua_istable(L,-1)); /* get class static metatable */
+  lua_pushstring(L,".instance"); /* prepare key */
+
+  SWIG_Lua_get_class_metatable(L,clss->fqname); /* get class metatable */
+  assert(lua_istable(L,-1));
+  lua_pushstring(L,".static"); /* prepare key */
+  lua_pushvalue(L, -4); /* push static class TABLE */
+  assert(lua_istable(L,-1));
+  lua_rawset(L,-3); /* assign static class table(!NOT metatable) as ".static" member of class metatable */
+  lua_rawset(L,-3); /* assign class metatable as ".instance" member of class static METATABLE */
+  lua_pop(L,2);
+  assert(lua_gettop(L) == begin);
+}
+#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
+SWIGINTERN void SWIG_Lua_elua_class_register_instance(lua_State *L, swig_lua_class *clss)
+{
+  int begin = lua_gettop(L);
+  /* if name already there (class is already registered) then do nothing */
+  SWIG_Lua_get_class_registry(L);  /* get the registry */
+  lua_pushstring(L,clss->fqname);  /* get the name */
+  lua_rawget(L,-2);
+  if(!lua_isnil(L,-1)) {
+    lua_pop(L,2);
+    assert(lua_gettop(L)==begin);
+    return;
+  }
+  lua_pop(L,2); /* tidy stack */
+  /* Recursively initialize all bases */
+  int i = 0;
+  for(i=0;clss->bases[i];i++)
+  {
+    SWIG_Lua_elua_class_register_instance(L,clss->bases[i]);
+  }
+  /* Again, get registry and push name */
+  SWIG_Lua_get_class_registry(L);  /* get the registry */
+  lua_pushstring(L,clss->fqname);  /* get the name */
+  assert(clss->metatable);
+  lua_pushrotable(L, (void*)(clss->metatable));    /* create the metatable */
+  lua_rawset(L,-3);
+  lua_pop(L,1);
+  assert(lua_gettop(L) == begin);
 }
+#endif // elua && eluac
 
 /* -----------------------------------------------------------------------------
  * Class/structure conversion fns
  * ----------------------------------------------------------------------------- */
 
 /* helper to add metatable to new lua object */
-SWIGINTERN void _SWIG_Lua_AddMetatable(lua_State* L,swig_type_info *type)
+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);
+    SWIG_Lua_get_class_metatable(L,((swig_lua_class*)(type->clientdata))->fqname);
     if (lua_istable(L,-1))
     {
       lua_setmetatable(L,-2);
@@ -936,9 +1473,9 @@ SWIGINTERN void _SWIG_Lua_AddMetatable(lua_State* L,swig_type_info *type)
 }
 
 /* pushes a new object into the lua stack */
-SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State* L,void* ptr,swig_type_info *type, int own)
+SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own)
 {
-  swig_lua_userdata* usr;
+  swig_lua_userdata *usr;
   if (!ptr){
     lua_pushnil(L);
     return;
@@ -954,9 +1491,9 @@ SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State* L,void* ptr,swig_type_info *t
 
 /* 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)
+SWIGRUNTIME int  SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type_info *type,int flags)
 {
-  swig_lua_userdata* usr;
+  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 */
@@ -983,9 +1520,9 @@ SWIGRUNTIME int  SWIG_Lua_ConvertPtr(lua_State* L,int index,void** ptr,swig_type
   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;
+SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State *L,int index,swig_type_info *type,int flags,
+       int argnum,const char *func_name){
+  void *result;
   if (!SWIG_IsOK(SWIG_ConvertPtr(L,index,&result,type,flags))){
     luaL_error (L,"Error in %s, expected a %s at argument number %d\n",
 		func_name,(type && type->str)?type->str:"void*",argnum);
@@ -994,9 +1531,9 @@ SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State* L,int index,swig_type_info *typ
 }
 
 /* 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)
+SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type)
 {
-  swig_lua_rawdata* raw;
+  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;
@@ -1006,9 +1543,9 @@ SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State* L,void* ptr,size_t size,swig_t
 }
     
 /* 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)
+SWIGRUNTIME int  SWIG_Lua_ConvertPacked(lua_State *L,int index,void *ptr,size_t size,swig_type_info *type)
 {
-  swig_lua_rawdata* raw;
+  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 */
@@ -1022,7 +1559,7 @@ SWIGRUNTIME int  SWIG_Lua_ConvertPacked(lua_State* L,int index,void* ptr,size_t
 /* 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;
+  swig_lua_userdata *usr;
   if (lua_isuserdata(L,tp))
   {
     usr=(swig_lua_userdata*)lua_touserdata(L,tp);  /* get data */
@@ -1034,7 +1571,7 @@ SWIGRUNTIME const char *SWIG_Lua_typename(lua_State *L, int tp)
 }
 
 /* lua callable function to get the userdata's type */
-SWIGRUNTIME int SWIG_Lua_type(lua_State* L)
+SWIGRUNTIME int SWIG_Lua_type(lua_State *L)
 {
   lua_pushstring(L,SWIG_Lua_typename(L,1));
   return 1;
@@ -1043,7 +1580,7 @@ SWIGRUNTIME int SWIG_Lua_type(lua_State* L)
 /* lua callable function to compare userdata's value
 the issue is that two userdata may point to the same thing
 but to lua, they are different objects */
-SWIGRUNTIME int SWIG_Lua_equal(lua_State* L)
+SWIGRUNTIME int SWIG_Lua_equal(lua_State *L)
 {
   int result;
   swig_lua_userdata *usr1,*usr2;
@@ -1064,7 +1601,7 @@ SWIGRUNTIME int SWIG_Lua_equal(lua_State* L)
 #if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
 /* Install Constants */
 SWIGINTERN void
-SWIG_Lua_InstallConstants(lua_State* L, swig_lua_const_info constants[]) {
+SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]) {
   int i;
   for (i = 0; constants[i].type; i++) {
     switch(constants[i].type) {
@@ -1118,7 +1655,7 @@ 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) {
+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 */
diff --git a/Lib/lua/luaruntime.swg b/Lib/lua/luaruntime.swg
index 3ca489ffa..ebb997897 100644
--- a/Lib/lua/luaruntime.swg
+++ b/Lib/lua/luaruntime.swg
@@ -36,20 +36,10 @@ SWIGEXPORT int SWIG_init(lua_State* L) /* default Lua action */
   SWIG_PropagateClientData();
 #endif
 
-#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
+#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) || defined(SWIG_LUA_ELUA_EMULATE)
   /* add a global fn */
   SWIG_Lua_add_function(L,"swig_type",SWIG_Lua_type);
   SWIG_Lua_add_function(L,"swig_equals",SWIG_Lua_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);
-  }
 #endif
 
 #if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
@@ -59,17 +49,35 @@ SWIGEXPORT int SWIG_init(lua_State* L) /* default Lua action */
       SWIG_Lua_init_base_class(L,(swig_lua_class*)(swig_types[i]->clientdata));
     }
   }
-  /* additional registration structs & classes in lua */
+  int globalRegister = 0;
+#ifdef SWIG_LUA_MODULE_GLOBAL
+  globalRegister = 1;
+#endif
+
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
+  SWIG_Lua_namespace_register(L,&swig___Module, globalRegister);
+#endif
+
+#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
   for (i = 0; swig_types[i]; i++){
     if (swig_types[i]->clientdata){
-      SWIG_Lua_class_register(L,(swig_lua_class*)(swig_types[i]->clientdata));
+      SWIG_Lua_elua_class_register_instance(L,(swig_lua_class*)(swig_types[i]->clientdata));
     }
   }
 #endif
 
-#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
-  /* constants */
-  SWIG_Lua_InstallConstants(L,swig_constants);
+#if defined(SWIG_LUA_ELUA_EMULATE)
+  lua_newtable(L);
+  SWIG_Lua_elua_emulate_register(L,swig___Module.ns_methods);
+  SWIG_Lua_elua_emulate_register_clear(L);
+  if(globalRegister) {
+    lua_pushstring(L,swig___Module.name);
+    lua_pushvalue(L,-2);
+    lua_rawset(L,-4);
+  }
+#endif
+
 #endif
 
 #if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)