The Lua Class is not a meta table now. It is a normal table, has a key named ".isclass", and a meta table has been set to it.

SunLightJuly · SunLightJuly · commit 5a997d196319 · 2014-09-18T14:04:01.000+08:00
To judge a Lua Class's type, must use it's meta table.
All the origin keys (in c/c++) were stored in Lua Class's meta table (and it's "parents's" meta table) .
If a origin key was overrided in Lua, it was backup in a table named ".backup". This backup table is a key of the meta table.
ONLY a origin key was overrided, you can use "tolua. getcfunction(class or object, key_name)" to return it, otherwise, the function return nil.
diff --git a/lua/tolua/tolua_event.c b/lua/tolua/tolua_event.c
@@ -130,6 +130,40 @@ static int module_newindex_event (lua_State* L)
     return 0;
 }
 
+static int class_table_get_index (lua_State* L)
+{
+    // stack:  obj key ... obj
+    
+    while (lua_getmetatable(L,-1)) {   /* stack: obj key obj mt */
+        lua_remove(L,-2);                      /* stack: ... mt */
+        
+        lua_pushvalue(L,2);                    /* stack: ... mt key */
+        lua_rawget(L,-2);                      /* stack: ... mt value */
+        if (!lua_isnil(L,-1)) {
+            return 1;
+        } else {
+            lua_pop(L,1);
+        }
+        
+        /* try C/C++ variable */
+        lua_pushstring(L,".get");
+        lua_rawget(L,-2);                   /* stack: obj key ... mt tget */
+        if (lua_istable(L,-1)) {
+            lua_pushvalue(L,2);  /* stack: obj key ... mt tget key */
+            lua_rawget(L,-2);    /* stack: obj key ... mt tget value */
+            if (lua_iscfunction(L,-1)) {
+                lua_call(L,0,1);
+                return 1;
+            } else if (lua_istable(L,-1)) {
+                return 1;
+            }
+            lua_pop(L, 2);
+        }
+    }
+    lua_pushnil(L);
+    return 1;
+}
+
 /* Class index function
     * If the object is a userdata (ie, an object), it searches the field in
     * the alternative table stored in the corresponding "ubox" table.
@@ -227,13 +261,65 @@ static int class_index_event (lua_State* L)
     }
     else if (t== LUA_TTABLE)
     {
-        module_index_event(L);
+        lua_pushvalue(L,1);
+        class_table_get_index(L);
         return 1;
     }
     lua_pushnil(L);
     return 1;
 }
 
+static int class_backup_before_newindex (lua_State* L)
+{
+    /* stack: t k v */
+    int m;
+    
+    lua_pushvalue(L, 1);
+    m = lua_getmetatable(L,-1);  /* stack: t k v t mt */
+    while (m>0 && lua_istable(L,-1)) {
+        lua_remove(L, -2);       /* stack: t k v mt */
+        //Check if key had been backup
+        lua_pushstring(L, ".backup");
+        lua_rawget(L, -2);  /* stack: t k v mt mt[".backup"] */
+        if (!lua_isnil(L, -1)) {
+            lua_pushvalue(L, 2);    /* stack: t k v mt mt[".backup"] k */
+            lua_rawget(L, -2);
+            if (!lua_isnil(L, -1)) {
+                // key had been backup
+                return 0;
+            }
+            lua_pop(L, 1);
+        }
+        lua_pop(L, 1);  /* stack: t k v mt */
+        
+        //Check if key is exist in mt
+        lua_pushvalue(L, 2);
+        lua_rawget(L, -2);  /* stack: t k v mt mt[k] */
+        if (!lua_isnil(L, -1)) {
+            lua_pushvalue(L, -2);   /* stack: t k v mt mt[k] mt */
+            lua_pushstring(L, ".backup");
+            lua_rawget(L, -2);  /* stack: t k v mt mt[k] mt mt[".backup"] */
+            if (lua_isnil(L, -1)) {
+                //Create a table and set to mt[".backup"]
+                lua_pop(L, 1);  /* stack: t k v mt mt[k] mt */
+                lua_pushstring(L, ".backup");
+                lua_newtable(L);
+                lua_rawset(L, -3);
+                lua_pushstring(L, ".backup");
+                lua_rawget(L, -2);  /* stack: t k v mt mt[k] mt mt[".backup"] */
+            }
+            lua_pushvalue(L, 2);    /* stack: t k v mt mt[k] mt mt[".backup"] k */
+            lua_pushvalue(L, -4);   /* stack: t k v mt mt[k] mt mt[".backup"] k mt[k] */
+            lua_rawset(L, -3);
+            return 0;
+        }
+        lua_pop(L, 1);  /* stack: t k v mt */
+        m = lua_getmetatable(L,-1);  /* stack: t k v mt base_mt */
+    }
+    
+    return 0;
+}
+
 /* Newindex function
     * It first searches for a C/C++ varaible to be set.
     * Then, it either stores it in the alternative ubox table (in the case it is
@@ -292,24 +378,46 @@ static int class_newindex_event (lua_State* L)
     }
     else if (t== LUA_TTABLE)
     {
-        module_newindex_event(L);
+        lua_getmetatable(L,1);  /* stack: t k v mt */
+        lua_pushstring(L,".set");
+        lua_rawget(L,-2);       /* stack: t k v mt tset */
+        if (lua_istable(L,-1)) {
+            lua_pushvalue(L,2);  /* stack: t k v mt tset k */
+            lua_rawget(L,-2);
+            if (lua_iscfunction(L,-1)) {  /* ... func */
+                lua_pushvalue(L,1); /* ... func t */
+                lua_pushvalue(L,3); /* ... func t v */
+                lua_call(L,2,0);
+                return 0;
+            }
+        }
+		lua_settop(L,3);
+        class_backup_before_newindex(L);
+		lua_settop(L,3);
+        lua_getmetatable(L,1);  /* stack: t k v mt */
+        lua_replace(L, 1);      /* stack: mt k v */
+		lua_rawset(L,1);
     }
     return 0;
 }
 
 static int class_call_event(lua_State* L) {
 
     if (lua_istable(L, 1)) {
-        lua_pushstring(L, ".call");
-        lua_rawget(L, 1);
-        if (lua_isfunction(L, -1)) {
-
-            lua_insert(L, 1);
-            lua_call(L, lua_gettop(L)-1, 1);
-
-            return 1;
-        };
-    };
+        //class is not a metatable now, so must get it's metatable to access ".call" function. 2014.6.5 by SunLightJuly
+        if (lua_getmetatable(L, 1)) {
+            lua_replace(L, 1);
+            lua_pushstring(L, ".call");
+            lua_rawget(L, 1);
+            if (lua_isfunction(L, -1)) {
+                
+                lua_insert(L, 1);
+                lua_call(L, lua_gettop(L)-1, 1);
+                
+                return 1;
+            }
+        }
+    }
     tolua_error(L,"Attempt to call a non-callable object.",NULL);
     return 0;
 };
diff --git a/lua/tolua/tolua_is.c b/lua/tolua/tolua_is.c
@@ -120,7 +120,22 @@ static  int lua_isusertable (lua_State* L, int lo, const char* type)
 {
     int r = 0;
     if (lo < 0) lo = lua_gettop(L)+lo+1;
-    lua_pushvalue(L,lo);
+    lua_pushvalue(L, lo);                   // stack: ... table
+
+    // A class table must use metatable to get it's type now. 2014.6.5 by SunLightJuly
+    if (lua_istable(L, -1)) {
+        lua_pushliteral(L, ".isclass");
+        lua_rawget(L, -2);                  // stack: ... table class_flag
+        if (!lua_isnil(L, -1)) {
+            lua_pop(L, 1);                  // stack: ... table
+            if (lua_getmetatable(L, -1)) {  // stack: ... table mt
+                lua_remove(L, -2);          // stack: ... mt
+            }
+        } else {
+            lua_pop(L, 1);                  // stack: ... table
+        }
+    }
+    
     lua_rawget(L,LUA_REGISTRYINDEX);  /* get registry[t] */
     if (lua_isstring(L,-1))
     {
diff --git a/lua/tolua/tolua_map.c b/lua/tolua/tolua_map.c
@@ -292,6 +292,44 @@ static int tolua_bnd_getpeer(lua_State* L) {
 };
 #endif
 
+/* Get the index which have been override
+    2014.6.5 by SunLightJuly
+ */
+static int tolua_bnd_getcfunction(lua_State* L) {
+    if (!lua_isstring(L, 2)) {
+        lua_pushstring(L, "Invalid argument #2 to getcfunction: string expected.");
+        lua_error(L);
+    }
+    
+    if (!lua_getmetatable(L, 1)) {
+        lua_pushstring(L, "Invalid argument #1 to getcfunction: class or object expected.");
+        lua_error(L);
+    }
+    
+    /* stack: class key mt */
+    while (1) {
+        lua_pushstring(L, ".backup");
+        lua_rawget(L, -2);  /* stack: class key mt mt[".backup"] */
+        if (!lua_isnil(L, -1)) {
+            lua_pushvalue(L, 2);    /* stack: class key mt mt[".backup"] key */
+            lua_rawget(L, -2);
+            if (!lua_isnil(L, -1)) { // key had been found
+                return 1;
+            }
+            lua_pop(L, 1);
+        }
+        lua_pop(L, 1);  /* stack: class key mt */
+        
+        if (!lua_getmetatable(L, -1)) {
+            break;
+        }
+        /* stack: class key mt base_mt */
+        lua_remove(L, -2);  /* stack: class key base_mt */
+    }
+    
+    return 0;
+}
+
 /* static int class_gc_event (lua_State* L); */
 
 TOLUA_API void tolua_open (lua_State* L)
@@ -372,6 +410,7 @@ TOLUA_API void tolua_open (lua_State* L)
         tolua_function(L, "setpeer", tolua_bnd_setpeer);
         tolua_function(L, "getpeer", tolua_bnd_getpeer);
 #endif
+        tolua_function(L,"getcfunction", tolua_bnd_getcfunction);
 
         tolua_endmodule(L);
         tolua_endmodule(L);
@@ -442,13 +481,27 @@ TOLUA_API void tolua_usertype (lua_State* L, const char* type)
 */
 TOLUA_API void tolua_beginmodule (lua_State* L, const char* name)
 {
-    if (name)
-    {
-        lua_pushstring(L,name);
-        lua_rawget(L,-2);
-    }
-    else
+    if (name) { // ... module
+//---- now module[name] is a table, get it's metatable to store keys
+        // get module[name]
+        lua_pushstring(L,name); // ... module name
+        lua_rawget(L,-2);       // ... module module[name]
+        // Is module[name] a class table?
+        lua_pushliteral(L, ".isclass");
+        lua_rawget(L, -2);                  // stack: ... module module[name] class_flag
+        if (lua_isnil(L, -1)) {
+            lua_pop(L, 1);                  // stack: ... module module[name]
+            return;                         // not a class table, use origin table
+        }
+        lua_pop(L, 1);                      // stack: ... module class_table
+        // get metatable
+        if (lua_getmetatable(L, -1)) {  // ... module class_table mt
+            lua_remove(L, -2);          // ... module mt
+        }
+//---- by SunLightJuly, 2014.6.5
+    } else {
         lua_pushvalue(L,LUA_GLOBALSINDEX);
+    }
 }
 
 /* End module
@@ -579,8 +632,16 @@ TOLUA_API void tolua_cclass (lua_State* L, const char* lname, const char* name,
     lua_rawset(L,-3);
     */
 
-    luaL_getmetatable(L,name);
-    lua_rawset(L,-3);              /* assign class metatable to module */
+//---- create a new class table, set it's metatable, and assign it to module
+    lua_newtable(L);                    // stack: module lname table
+    luaL_getmetatable(L,name);          // stack: module lname table mt
+    lua_setmetatable(L, -2);            // stack: module lname table
+    //Use a key named ".isclass" to be a flag of class_table
+    lua_pushliteral(L, ".isclass");
+    lua_pushboolean(L, 1);
+    lua_rawset(L, -3);                  // stack: module lname table
+    lua_rawset(L, -3);                  // stack: module
+//---- by SunLightJuly, 2014.6.5
 
     /* now we also need to store the collector table for the const
        instances of the class */
