1 files changed, 122 insertions, 74 deletions
diff --git a/source/3rd-party/Luax/luax_class.inl b/source/3rd-party/Luax/luax_class.inl
index 45e6552..95965ff 100644
--- a/source/3rd-party/Luax/luax_class.inl
+++ b/source/3rd-party/Luax/luax_class.inl
@@ -2,17 +2,16 @@ namespace Luax
 {
 
 	//--------------------------------------------------------------------------------//
-	// 接口
 
 	///
 	/// 对不同类型，通过调用GetLuaClassName获得类型名，如果是派生类，GetClassName会被覆盖，指向luax_c_getupvalue。
 	///
-	template<typename T>
-	int LuaxNativeClass<T>::l_GetClassName(lua_State* L)
+	template<class TYPE, class BASE>
+	int LuaxNativeClass<TYPE, BASE>::_GetClassName(lua_State* L)
 	{
 		LUAX_SETUP(L, "*");
 
-		cc8* type = T::GetLuaxClassName();
+		cc8* type = TYPE::GetLuaxClassName();
 		state.Push(type);
 		return 1;
 	}
@@ -22,12 +21,12 @@ namespace Luax
 	///
 	/// 注册工厂和单例共有的类成员
 	/// 
-	template<typename T>
-	void LuaxNativeClass<T>::RegisterLuaxClass(LuaxState& state)
+	template<class TYPE, class BASE>
+	void LuaxNativeClass<TYPE, BASE>::RegisterLuaxClassShared(LuaxState& state)
 	{
 		luaL_Reg regTable[] = {
-			{ "GetClass",     l_GetClass     },
-			{ "GetClassName", l_GetClassName },
+			{ "GetClass",     _GetClass     },
+			{ "GetClassName", _GetClassName },
 			{ NULL,           NULL           }
 		};
 
@@ -37,11 +36,11 @@ namespace Luax
 	///
 	/// 工厂类的成员，注册在class table
 	///
-	template<typename T>
-	void LuaxNativeClass<T>::RegisterLuaxFactoryClass(LuaxState& state)
+	template<class TYPE, class BASE>
+	void LuaxNativeClass<TYPE, BASE>::RegisterLuaxFactoryClass(LuaxState& state)
 	{
 		luaL_Reg regTable[] = {
-			{ "GetRefTable", l_GetRefTable },
+			{ "GetRefTable", _GetRefTable },
 			{ NULL,          NULL          }
 		};
 
@@ -51,8 +50,8 @@ namespace Luax
 	///
 	/// 单例类的成员，注册在class table
 	///
-	template<typename T>
-	void LuaxNativeClass<T>::RegisterLuaxSingletonClass(LuaxState& state)
+	template<class TYPE, class BASE>
+	void LuaxNativeClass<TYPE, BASE>::RegisterLuaxSingletonClass(LuaxState& state)
 	{
 		luaL_Reg regTable[] = {
 			{ NULL, NULL }
@@ -61,33 +60,70 @@ namespace Luax
 		state.RegisterMethods(regTable);
 	}
 
-	template<typename T>
-	void LuaxNativeClass<T>::PushLuaxClassTable(LuaxState& state)
+	template<class TYPE, class BASE>
+	void LuaxNativeClass<TYPE, BASE>::PushLuaxClassTable(LuaxState& state)
 	{
 		assert(mClassTable);
 
 		mClassTable.PushRef(state);
 	}
 
-	template<typename T>
-	void LuaxNativeClass<T>::SetLuaxClassTableRef(LuaxState& state, int idx)
+	template<class TYPE, class BASE>
+	void LuaxNativeClass<TYPE, BASE>::SetLuaxClassTableRef(LuaxState& state, int idx)
 	{
 		mClassTable.SetRef(state, idx);
 	}
 
-	template<typename T>
-	LuaxNativeClass<T>::LuaxNativeClass()
+	template<class TYPE, class BASE>
+	LuaxNativeClass<TYPE, BASE>::LuaxNativeClass()
+		: mWatchDog() 
+#if LUAX_PROFILER 
+		, mSafer(false)
+#endif
+	{
+	}
+
+	template<class TYPE, class BASE>
+	LuaxNativeClass<TYPE, BASE>::~LuaxNativeClass()
+	{
+	}
+
+#if LUAX_PROFILER
+	template<class TYPE, class BASE>
+	void LuaxNativeClass<TYPE, BASE>::operator delete(void* pdead, size_t size)
+	{
+		if (pdead == nullptr)
+			return;
+		// 堆上创建的实例必须使用Release释放。
+		LuaxNativeClass* p = static_cast<LuaxNativeClass*>(pdead);
+		assert(p->mSafer);
+		::operator delete(pdead, size);
+	}
+#endif
+
+	template<class TYPE, class BASE>
+	void LuaxNativeClass<TYPE, BASE>::Retain()
 	{
+		++mWatchDog.mNativeRef;
 	}
 
-	template<typename T>
-	LuaxNativeClass<T>::~LuaxNativeClass()
+	template<class TYPE, class BASE>
+	void LuaxNativeClass<TYPE, BASE>::Release()
 	{
+		if (mWatchDog.mNativeRef > 0)
+			--mWatchDog.mNativeRef;
+		if (mWatchDog)
+		{
+#if LUAX_PROFILER
+			mSafer = true;
+#endif
+			delete this;
+		}
 	}
 
-	template<typename T>
+	template<class TYPE, class BASE>
 	template<typename U>
-	void LuaxNativeClass<T>::LuaxRetain(LuaxState& state, U* userdata)
+	void LuaxNativeClass<TYPE, BASE>::LuaxRetain(LuaxState& state, U* userdata)
 	{
 		if (PushLuaxRefTable(state))
 		{
@@ -103,9 +139,9 @@ namespace Luax
 		}
 	}
 
-	template<typename T>
+	template<class TYPE, class BASE>
 	template<typename U>
-	void LuaxNativeClass<T>::LuaxRelease(LuaxState& state, U* userdata)
+	void LuaxNativeClass<TYPE, BASE>::LuaxRelease(LuaxState& state, U* userdata)
 	{
 		if (PushLuaxRefTable(state))
 		{
@@ -139,10 +175,10 @@ namespace Luax
 		}
 	}
 
-	template<typename T>
-	bool LuaxNativeClass<T>::PushLuaxUserdata(LuaxState& state)
+	template<class TYPE, class BASE>
+	bool LuaxNativeClass<TYPE, BASE>::PushLuaxUserdata(LuaxState& state)
 	{
-		assert(!T::IsLuaxClassSingleton());
+		assert(!TYPE::IsLuaxClassSingleton());
 		if (!mUserdata)
 		{
 			BindToLua(state);
@@ -151,8 +187,8 @@ namespace Luax
 		return mUserdata.PushRef(state);
 	}
 
-	template<typename T>
-	bool LuaxNativeClass<T>::PushLuaxMemberTable(LuaxState& state)
+	template<class TYPE, class BASE>
+	bool LuaxNativeClass<TYPE, BASE>::PushLuaxMemberTable(LuaxState& state)
 	{
 		int top = state.GetTop();
 		if (this->PushLuaxUserdata(state))
@@ -172,11 +208,11 @@ namespace Luax
 		return false;
 	}
 
-	template<typename T>
-	bool LuaxNativeClass<T>::PushLuaxRefTable(LuaxState& state)
+	template<class TYPE, class BASE>
+	bool LuaxNativeClass<TYPE, BASE>::PushLuaxRefTable(LuaxState& state)
 	{
 		// Singleton 
-		if (T::IsLuaxClassSingleton())
+		if (TYPE::IsLuaxClassSingleton())
 		{
 			if (!this->mSingletonRefTable) {
 				lua_newtable(state);
@@ -209,19 +245,21 @@ namespace Luax
 	///     member table 保存lua创建的实例的成员
 	///     class table  所有本类型的实例共有的函数表
 	///
-	template<typename T>
-	void LuaxNativeClass<T>::BindToLua(LuaxState& state)
+	/// BindToLua只会在第一次注册给Lua虚拟机时调用。
+	///
+	template<class TYPE, class BASE>
+	void LuaxNativeClass<TYPE, BASE>::BindToLua(LuaxState& state)
 	{
 		// 单例不能绑定userdata
-		assert(!T::IsLuaxClassSingleton());
+		assert(!TYPE::IsLuaxClassSingleton());
 		assert(!mUserdata);
 
 		///
-		/// 创建userdata并留在栈顶，注意地址要转换为T*，直接用this可能会导致多重继承的类丧失多态。
+		/// 创建userdata并留在栈顶，注意地址要转换为TYPE*，直接用this可能会导致多重继承的类丧失多态。
 		/// 如果直接传this进去，在多重继承情况下，是拿不到另一头的虚函数表的。所以这里需要将this
 		/// 转换为整个对象的低地址，这样可以拿到另一个基类的虚函数表，通过另一个基类实现多态。
 		///
-		T* p = static_cast<T*>(this);
+		TYPE* p = static_cast<TYPE*>(this);
 		state.PushPtrUserdata(p);
 
 		lua_newtable(state); // ref table，无法在lua处访问，用来管理C对象的生命周期
@@ -239,10 +277,10 @@ namespace Luax
 		int refTable = top - 2;
 
 		// ref table 注册 __tostring 和 __gc
-		lua_pushcfunction(state, _Tostring);
+		lua_pushcfunction(state, __tostring);
 		lua_setfield(state, refTable, "__tostring");
 
-		lua_pushcfunction(state, _GC);
+		lua_pushcfunction(state, __gc);
 		lua_setfield(state, refTable, "__gc");
 
 		// ref table 的 __index 和 __newindex 设为 member table
@@ -260,13 +298,19 @@ namespace Luax
 		// 设置一个userdata的弱引用，方便通过PushLuaUserdata方法返回lua对象
 		mUserdata.SetRef(state, -1);
 		assert(mUserdata);
+
+		// 增加一个虚拟机引用，在GC时-1
+		++mWatchDog.mVMRef;
+#if LUAX_PROFILER
+		mRefVMs.insert(state.GetVM());
+#endif
 	}
 
 	///
 	/// 成员引用管理
 	///
-	template<typename T>
-	void LuaxNativeClass<T>::SetLuaxMemberRef(LuaxState& state, LuaxMemberRef& memRef, int idx)
+	template<class TYPE, class BASE>
+	void LuaxNativeClass<TYPE, BASE>::SetLuaxMemberRef(LuaxState& state, LuaxMemberRef& memRef, int idx)
 	{
 		ClearLuaxMemberRef(state, memRef);
 		if (!lua_isnil(state, idx))
@@ -281,8 +325,8 @@ namespace Luax
 		}
 	}
 
-	template<typename T>
-	bool LuaxNativeClass<T>::PushLuaxMemberRef(LuaxState& state, LuaxMemberRef& memRef)
+	template<class TYPE, class BASE>
+	bool LuaxNativeClass<TYPE, BASE>::PushLuaxMemberRef(LuaxState& state, LuaxMemberRef& memRef)
 	{
 		if (memRef)
 		{
@@ -301,8 +345,8 @@ namespace Luax
 		return false;
 	}
 
-	template<typename T> 
-	bool LuaxNativeClass<T>::PushLuaxMemberRef(LuaxState& state, int refID)
+	template<class TYPE, class BASE> 
+	bool LuaxNativeClass<TYPE, BASE>::PushLuaxMemberRef(LuaxState& state, int refID)
 	{
 		if (PushLuaxRefTable(state))
 		{
@@ -317,8 +361,8 @@ namespace Luax
 		return false;
 	}
 
-	template<typename T>
-	void LuaxNativeClass<T>::ClearLuaxMemberRef(LuaxState& state, LuaxMemberRef& memRef)
+	template<class TYPE, class BASE>
+	void LuaxNativeClass<TYPE, BASE>::ClearLuaxMemberRef(LuaxState& state, LuaxMemberRef& memRef)
 	{
 		if (memRef)
 		{
@@ -336,16 +380,20 @@ namespace Luax
 	///
 	/// 释放工厂创建的实例
 	///
-	template<typename T>
-	int LuaxNativeClass<T>::_GC(lua_State* L)
+	template<class TYPE, class BASE>
+	int LuaxNativeClass<TYPE, BASE>::__gc(lua_State* L)
 	{
+		LUAX_STATE(L);
+		TYPE* self = state.GetUserdata<TYPE>(1);
+		assert(self);
+
 #if LUAX_PROFILER 
-		std::cout << "Luax: GC<" << T::GetLuaxClassName() << ">\n";
+		std::cout << "Luax: GC<" << TYPE::GetLuaxClassName() << ">\n";
 #endif
 
-		LUAX_SETUP(L, "U");
-		T* self = state.GetUserdata<T>(1);
-		delete self;
+		--self->mWatchDog.mVMRef;
+		self->LuaxNativeClass<TYPE, BASE>::Release();
+
 		return 0;
 	}
 
@@ -353,14 +401,14 @@ namespace Luax
 	/// 输出格式如下:
 	/// 地址 类名
 	///
-	template<typename T>
-	int LuaxNativeClass<T>::_Tostring(lua_State* L)
+	template<class TYPE, class BASE>
+	int LuaxNativeClass<TYPE, BASE>::__tostring(lua_State* L)
 	{
 		// params: 
 		// 1: userdata
 
 		LUAX_STATE(L);
-		T* self = state.GetUserdata<T>(1);
+		TYPE* self = state.GetUserdata<TYPE>(1);
 		if (self)
 		{
 			cc8* classname = "";
@@ -373,7 +421,7 @@ namespace Luax
 			}
 			else
 			{
-				classname = T::GetLuaxClassName();
+				classname = TYPE::GetLuaxClassName();
 			}
 			lua_pushfstring(L, "%s: %p", classname, self);
 			return 1;
@@ -386,8 +434,8 @@ namespace Luax
 	/// 派生出子类，在lua里对派生类的成员和行为进行重新设计，但是保证了userdata的统一。Native class的派生提供__init支持，在
 	/// native实体创建后可以使用__init进行初始化，派生类拥有和基类一样的New参数列表，且native对象是一样的类型。
 	///
-	template<typename T>
-	int LuaxNativeClass<T>::l_ExtendFactory(lua_State* L)
+	template<class TYPE, class BASE>
+	int LuaxNativeClass<TYPE, BASE>::_ExtendFactory(lua_State* L)
 	{
 		// upvalues:
 		// 1: base class 
@@ -414,13 +462,13 @@ namespace Luax
 
 		// .Extend()
 		lua_pushvalue(L, inheritClass);
-		lua_pushcclosure(L, l_ExtendFactory, 1);
+		lua_pushcclosure(L, _ExtendFactory, 1);
 		lua_setfield(L, -2, "Extend");
 
 		// .New() 
 		lua_pushvalue(L, inheritClass); 
 		lua_getfield(L, baseClass, "New");
-		lua_pushcclosure(L, l_New, 2);
+		lua_pushcclosure(L, _New, 2);
 		lua_setfield(L, -2, "New");
 
 		// __base = baseClass
@@ -438,8 +486,8 @@ namespace Luax
 		return 1;
 	}
 
-	template<typename T>
-	int LuaxNativeClass<T>::l_ExtendSingleton(lua_State* L)
+	template<class TYPE, class BASE>
+	int LuaxNativeClass<TYPE, BASE>::_ExtendSingleton(lua_State* L)
 	{
 		// upvalues:
 		// 1: base class 
@@ -466,7 +514,7 @@ namespace Luax
 
 		// .Extend()
 		lua_pushvalue(L, inheritClass);
-		lua_pushcclosure(L, l_ExtendFactory, 1);
+		lua_pushcclosure(L, _ExtendFactory, 1);
 		lua_setfield(L, -2, "Extend");
 
 		// __base = baseClass
@@ -485,8 +533,8 @@ namespace Luax
 	}
 #endif /*LUAX_ENABLE_NATIVE_EXTEND*/
 
-	template<typename T> 
-	int LuaxNativeClass<T>::l_GetClass(lua_State* L)
+	template<class TYPE, class BASE> 
+	int LuaxNativeClass<TYPE, BASE>::_GetClass(lua_State* L)
 	{
 		LUAX_STATE(L);
 		if (!mClassTable)
@@ -496,19 +544,19 @@ namespace Luax
 		return 1;
 	}
 
-	template<typename T>
-	int LuaxNativeClass<T>::l_GetRefTable(lua_State* L)
+	template<class TYPE, class BASE>
+	int LuaxNativeClass<TYPE, BASE>::_GetRefTable(lua_State* L)
 	{
 		LUAX_STATE(L);
-		T* self = state.GetUserdata<T>(1);
+		TYPE* self = state.GetUserdata<TYPE>(1);
 		bool success = self->PushLuaxRefTable(state);
 		if (!success)
 			lua_pushnil(L);
 		return 1;
 	}
 
-	template<typename T>
-	int LuaxNativeClass<T>::l_New(lua_State* L)
+	template<class TYPE, class BASE>
+	int LuaxNativeClass<TYPE, BASE>::_New(lua_State* L)
 	{
 		LUAX_STATE(L);
 
@@ -580,7 +628,7 @@ namespace Luax
 		return 0;
 	}
 
-	template<typename T> LuaxStrongRef LuaxNativeClass<T>::mClassTable;        // class table
-	template<typename T> LuaxStrongRef LuaxNativeClass<T>::mSingletonRefTable; // 单例
+	template<class TYPE, class BASE> LuaxStrongRef LuaxNativeClass<TYPE, BASE>::mClassTable;        // class table
+	template<class TYPE, class BASE> LuaxStrongRef LuaxNativeClass<TYPE, BASE>::mSingletonRefTable; // 单例
 
 }
 \ No newline at end of file