Lua 5.2支持

UniLua/LuaTable.cs

@@ -0,0 +1,581 @@
+ 
+// #define DEBUG_DUMMY_TVALUE_MODIFY
+
+using System;
+using System.Collections.Generic;
+
+namespace UniLua
+{
+	using ULDebug = UniLua.Tools.ULDebug;
+
+	public class LuaTable {
+		public LuaTable MetaTable;
+		public uint NoTagMethodFlags;
+
+		public LuaTable(LuaState l) {
+			InitLuaTable(l);
+		}
+
+		~LuaTable()
+		{
+			Recycle();
+		}
+
+		public StkId Get(ref TValue key)
+		{
+			if(key.Tt == (int)LuaType.LUA_TNIL) { return TheNilValue; }
+
+			if(IsPositiveInteger(ref key))
+				{ return GetInt((int)key.NValue); }
+
+			if(key.Tt == (int)LuaType.LUA_TSTRING)
+				{ return GetStr(key.SValue()); }
+
+			var h = key.GetHashCode();
+			for(var node = GetHashNode(h); node != null; node = node.Next) {
+				if(node.Key.V == key) {
+					{ return node.Val; }
+				}
+			}
+
+			return TheNilValue;
+		}
+
+		public StkId GetInt(int key)
+		{
+			if(0 < key && key-1 < ArrayPart.Length)
+				{ return ArrayPart[key-1]; }
+
+			var k = new TValue();
+			k.SetNValue(key);
+			for(var node = GetHashNode(ref k); node != null; node = node.Next) {
+				if(node.Key.V.TtIsNumber() && node.Key.V.NValue == (double)key) {
+					return node.Val;
+				}
+			}
+
+			return TheNilValue;
+		}
+
+		public StkId GetStr(string key)
+		{
+			var h = key.GetHashCode();
+			for(var node = GetHashNode(h); node != null; node = node.Next) {
+				if(node.Key.V.TtIsString() && node.Key.V.SValue() == key)
+					{ return node.Val; }
+			}
+
+			return TheNilValue;
+		}
+
+		public void Set(ref TValue key, ref TValue val)
+		{
+			var cell = Get(ref key);
+			if(cell == TheNilValue) {
+				cell = NewTableKey(ref key);
+			}
+			cell.V.SetObj(ref val);
+		}
+
+		public void SetInt(int key, ref TValue val)
+		{
+			var cell = GetInt(key);
+			if(cell == TheNilValue) {
+				var k = new TValue();
+				k.SetNValue(key);
+				cell = NewTableKey(ref k);
+			}
+			cell.V.SetObj(ref val);
+			// Console.WriteLine(string.Format("---------------- SetInt {0} -> {1}", key, val));
+			// DumpParts();
+		}
+
+		/*
+		** returns the index of a `key' for table traversals. First goes all
+		** elements in the array part, then elements in the hash part. The
+		** beginning of a traversal is signaled by -1.
+		*/
+		private int FindIndex(StkId key)
+		{
+			if(key.V.TtIsNil())
+				{ return -1; }
+
+			// is `key' inside array part?
+			int i = ArrayIndex(ref key.V);
+			if(0 < i && i <= ArrayPart.Length)
+				{ return i-1; }
+
+			var n = GetHashNode(ref key.V);
+			// check whether `key' is somewhere in the chain
+			for(;;) {
+				if(L.V_RawEqualObj(ref n.Key.V, ref key.V))
+					{ return ArrayPart.Length + n.Index; }
+				n = n.Next;
+
+				// key not found
+				if(n == null) { L.G_RunError("invalid key to 'next'"); }
+			}
+		}
+
+		public bool Next(StkId key, StkId val)
+		{
+			// find original element
+			int i = FindIndex(key);
+
+			// try first array part
+			for(i++; i<ArrayPart.Length; ++i) {
+				if(!ArrayPart[i].V.TtIsNil()) {
+					key.V.SetNValue(i+1);
+					val.V.SetObj(ref ArrayPart[i].V);
+					return true;
+				}
+			}
+
+			// then hash part
+			for(i-=ArrayPart.Length; i<HashPart.Length; ++i) {
+				if(!HashPart[i].Val.V.TtIsNil()) {
+					key.V.SetObj(ref HashPart[i].Key.V);
+					val.V.SetObj(ref HashPart[i].Val.V);
+					return true;
+				}
+			}
+			return false;
+		}
+
+		public int Length
+		{ get {
+			uint j = (uint)ArrayPart.Length;
+			if(j > 0 && ArrayPart[j-1].V.TtIsNil()) {
+				/* there is a boundary in the array part: (binary) search for it */
+				uint i = 0;
+				while(j - i > 1) {
+					uint m = (i+j)/2;
+					if(ArrayPart[m-1].V.TtIsNil()) { j = m; }
+					else { i = m; }
+				}
+				return (int)i;
+			}
+			/* else must find a boundary in hash part */
+			else if(HashPart == DummyHashPart)
+				return (int)j;
+			else return UnboundSearch(j);
+		} }
+
+		public void Resize(int nasize, int nhsize)
+		{
+			int oasize = ArrayPart.Length;
+			var oldHashPart = HashPart;
+			if(nasize > oasize) // array part must grow?
+				SetArraryVector(nasize);
+
+			// create new hash part with appropriate size
+			SetNodeVector(nhsize);
+
+			// array part must shrink?
+			if(nasize < oasize) {
+				var oldArrayPart = ArrayPart;
+				ArrayPart = DummyArrayPart;
+				// re-insert elements from vanishing slice
+				for(int i=nasize; i<oasize; ++i) {
+					if(!oldArrayPart[i].V.TtIsNil())
+						{ SetInt(i+1, ref oldArrayPart[i].V); }
+				}
+				// shrink array
+				var newArrayPart = new StkId[nasize];
+				for(int i=0; i<nasize; ++i) {
+					newArrayPart[i] = oldArrayPart[i];
+				}
+				ArrayPart = newArrayPart;
+			}
+
+			// re-insert elements from hash part
+			for(int i=0; i<oldHashPart.Length; ++i) {
+				var node = oldHashPart[i];
+				if(!node.Val.V.TtIsNil()) {
+					Set(ref node.Key.V, ref node.Val.V);
+				}
+			}
+
+			if (oldHashPart != DummyHashPart)
+				RecycleHNode(oldHashPart);
+		}
+
+		//-----------------------------------------
+		//
+		// **** PRIVATE below ****
+		//
+		//-----------------------------------------
+
+		private class HNode
+		{
+			public int Index;
+			public StkId Key;
+			public StkId Val;
+			public HNode Next;
+
+			public void CopyFrom(HNode o)
+			{
+				Key.V.SetObj(ref o.Key.V);
+				Val.V.SetObj(ref o.Val.V);
+				Next = o.Next;
+			}
+		}
+
+		private LuaState L;
+
+		private StkId[] ArrayPart;
+		private HNode[] HashPart;
+		private int LastFree;
+
+		private static StkId TheNilValue;
+		private static StkId[] DummyArrayPart;
+		private static HNode DummyNode;
+		private static HNode[] DummyHashPart;
+
+		private const int MAXBITS = 30;
+		private const int MAXASIZE = (1 << MAXBITS);
+
+		static LuaTable()
+		{
+			TheNilValue = new StkId();
+			TheNilValue.V.SetNilValue();
+#if DEBUG_DUMMY_TVALUE_MODIFY
+			TheNilValue.V.Lock_ = true;
+#endif
+
+			DummyArrayPart = new StkId[0];
+
+			DummyNode = new HNode();
+			DummyNode.Key = TheNilValue;
+			DummyNode.Val = TheNilValue;
+			DummyNode.Next = null;
+
+			DummyHashPart = new HNode[1];
+			DummyHashPart[0] = DummyNode;
+			DummyHashPart[0].Index = 0;
+		}
+
+		#region Small Object Cache
+		private static HNode CacheHead = null;
+		private static object CacheHeadLock = new Object();
+
+		private void Recycle()
+		{
+			if (HashPart != null && HashPart != DummyHashPart)
+			{
+				RecycleHNode(HashPart);
+				HashPart = null;
+			}
+		}
+
+		private void RecycleHNode(HNode[] garbage)
+		{
+			if (garbage == null || garbage.Length == 0)
+				return;
+
+			for (int i = 0; i < garbage.Length-1; i++)
+			{
+				garbage[i].Next = garbage[i + 1];
+			}
+
+			lock(CacheHeadLock) {
+				garbage[garbage.Length - 1].Next = CacheHead;
+				CacheHead = garbage[0];
+			}
+		}
+
+		private HNode NewHNode()
+		{
+			HNode ret;
+			if (CacheHead == null)
+			{
+				ret = new HNode();
+				ret.Key = new StkId();
+				ret.Val = new StkId();
+			}
+			else
+			{
+				lock(CacheHeadLock) {
+					ret = CacheHead;
+					CacheHead = CacheHead.Next;
+				}
+				ret.Next = null;
+				ret.Index = 0;
+				ret.Key.V.SetNilValue();
+				ret.Val.V.SetNilValue();
+			}
+
+			return ret;
+		}
+		#endregion
+
+		private void InitLuaTable(LuaState lua)
+		{
+			L = lua;
+			ArrayPart = DummyArrayPart;
+			SetNodeVector(0);
+		}
+
+		private bool IsPositiveInteger(ref TValue v)
+		{
+			return (v.TtIsNumber() && v.NValue > 0 && (v.NValue % 1) == 0 && v.NValue <= int.MaxValue); //fix large number key bug
+		}
+
+		private HNode GetHashNode(int hashcode)
+		{
+			uint n = (uint)hashcode;
+			return HashPart[n % HashPart.Length];
+		}
+
+		private HNode GetHashNode(ref TValue v)
+		{
+			if(IsPositiveInteger(ref v)) { return GetHashNode((int)v.NValue); }
+
+			if(v.TtIsString()) { return GetHashNode(v.SValue().GetHashCode()); }
+
+			return GetHashNode(v.GetHashCode());
+		}
+
+		private void SetArraryVector(int size)
+		{
+			Utl.Assert(size >= ArrayPart.Length);
+
+			var newArrayPart = new StkId[size];
+			int i = 0;
+			for( ; i<ArrayPart.Length; ++i) {
+				newArrayPart[i] = ArrayPart[i];
+			}
+			for( ; i<size; ++i) {
+				newArrayPart[i] = new StkId();
+				newArrayPart[i].V.SetNilValue();
+			}
+			ArrayPart = newArrayPart;
+		}
+
+		private void SetNodeVector(int size)
+		{
+			if(size == 0) {
+				HashPart = DummyHashPart;
+				LastFree = size;
+				return;
+			}
+
+			int lsize = CeilLog2(size);
+			if(lsize > MAXBITS) { L.G_RunError("table overflow"); }
+
+			size = (1 << lsize);
+			HashPart = new HNode[size];
+			for(int i=0; i<size; ++i) {
+				HashPart[i] = NewHNode();
+				HashPart[i].Index = i;
+			}
+			LastFree = size;
+		}
+
+		private HNode GetFreePos()
+		{
+			while(LastFree > 0) {
+				var node = HashPart[--LastFree];
+				if(node.Key.V.TtIsNil()) { return node; }
+			}
+			return null;
+		}
+
+		/*
+		** returns the index for `key' if `key' is an appropriate key to live in
+		** the array part of the table, -1 otherwise.
+		*/
+		private int ArrayIndex(ref TValue k)
+		{
+			if(IsPositiveInteger(ref k))
+				return (int)k.NValue;
+			else
+				return -1;
+		}
+
+		private static readonly byte[] Log2_ = new byte[] {
+			0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+			6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+			7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+			7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+			8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+			8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+			8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
+			8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
+		};
+		private int CeilLog2(int x)
+		{
+			Utl.Assert(x > 0);
+			int l = 0;
+			x--;
+			while(x >= 256) { l+=8; x>>=8; }
+			return l + Log2_[x];
+		}
+
+		private int CountInt(ref TValue key, ref int[] nums)
+		{
+			int k = ArrayIndex(ref key);
+			if(0 < k && k <= MAXASIZE) {
+				nums[CeilLog2(k)]++;
+				return 1;
+			}
+			else return 0;
+		}
+
+		private int NumUseArray(ref int[] nums)
+		{
+			int ause = 0;
+			int i = 1;
+			for(int lg=0, ttlg=1; lg<=MAXBITS; lg++, ttlg*=2) {
+				int lc = 0; // counter
+				int lim = ttlg;
+				if(lim > ArrayPart.Length) {
+					lim = ArrayPart.Length;
+					if(i > lim) { break; } // no more elements to count
+				}
+
+				// count elements in range (2^(lg-1), 2^lg]
+				for(; i<=lim; ++i) {
+					if(!ArrayPart[i-1].V.TtIsNil()) { lc++; }
+				}
+				nums[lg] += lc;
+				ause += lc;
+			}
+			return ause;
+		}
+
+		private int NumUseHash(ref int[] nums, ref int nasize)
+		{
+			int totaluse = 0;
+			int ause = 0;
+			int i = HashPart.Length;
+			while(i-- > 0) {
+				var n = HashPart[i];
+				if(!n.Val.V.TtIsNil()) {
+					ause += CountInt(ref n.Key.V, ref nums);
+					totaluse++;
+				}
+			}
+			nasize += ause;
+			return totaluse;
+		}
+
+		private int ComputeSizes(ref int[] nums, ref int nasize)
+		{
+			int a = 0;
+			int na = 0;
+			int n = 0;
+			for(int i=0, tti=1; tti/2<nasize; ++i, tti*=2) {
+				if(nums[i] > 0) {
+					a += nums[i];
+					if(a > tti/2) {
+						n = tti;
+						na = a;
+					}
+				}
+				if(a == nasize) { break; } // all elements already conted
+			}
+			nasize = n;
+			Utl.Assert(nasize/2 <= na && na <= nasize);
+			return na;
+		}
+
+		private static int[] Nums = new int[MAXBITS + 1];
+		private void Rehash(ref TValue k)
+		{
+			for(int i=0; i<=MAXBITS; ++i) { Nums[i] = 0; }
+
+			int nasize = NumUseArray(ref Nums);
+			int totaluse = nasize;
+			totaluse += NumUseHash(ref Nums, ref nasize);
+			nasize += CountInt(ref k, ref Nums);
+			totaluse++;
+			int na = ComputeSizes(ref Nums, ref nasize);
+			Resize(nasize, totaluse-na);
+		}
+
+		private void DumpParts()
+		{
+			Console.WriteLine("------------------ [DumpParts] enter -----------------------");
+			Console.WriteLine("<< Array Part >>");
+			for(var i=0; i<ArrayPart.Length; ++i) {
+				var n = ArrayPart[i];
+				Console.WriteLine(string.Format("i:{0} val:{1}", i, n.V));
+			}
+			Console.WriteLine("<< Hash Part >>");
+			for(var i=0; i<HashPart.Length; ++i) {
+				var n = HashPart[i];
+				var next = (n.Next == null) ? -1 : n.Next.Index;
+				Console.WriteLine(string.Format("i:{0} index:{1} key:{2} val:{3} next:{4}", i, n.Index, n.Key.V, n.Val.V, next));
+			}
+			Console.WriteLine("++++++++++++++++++ [DumpParts] leave +++++++++++++++++++++++");
+		}
+
+		private StkId NewTableKey(ref TValue k)
+		{
+			if(k.TtIsNil()) { L.G_RunError("table index is nil"); }
+
+			if(k.TtIsNumber() && System.Double.IsNaN(k.NValue))
+				{ L.G_RunError("table index is NaN"); }
+
+			var mp = GetHashNode(ref k);
+
+			// if main position is taken
+			if(!mp.Val.V.TtIsNil() || mp == DummyNode) {
+				var n = GetFreePos();
+				if(n == null) {
+					Rehash(ref k);
+					var cell = Get(ref k);
+					if(cell != TheNilValue) { return cell; }
+					return NewTableKey(ref k);
+				}
+
+				Utl.Assert(n != DummyNode);
+				var othern = GetHashNode(ref mp.Key.V);
+				// is colliding node out of its main position?
+				if(othern != mp) {
+					while(othern.Next != mp) { othern = othern.Next; }
+					othern.Next = n;
+					n.CopyFrom(mp);
+					mp.Next = null;
+					mp.Val.V.SetNilValue();
+				}
+				// colliding node is in its own main position
+				else {
+					n.Next = mp.Next;
+					mp.Next = n;
+					mp = n;
+				}
+			}
+
+			mp.Key.V.SetObj(ref k);
+			Utl.Assert(mp.Val.V.TtIsNil());
+			return mp.Val;
+		}
+
+		private int UnboundSearch(uint j)
+		{
+			uint i = j;
+			j++;
+			while(!GetInt((int)j).V.TtIsNil()) {
+				i = j;
+				j *= 2;
+
+				// overflow?
+				if(j > LuaLimits.MAX_INT) {
+					/* table was built with bad purposes: resort to linear search */
+					i = 1;
+					while(!GetInt((int)i).V.TtIsNil()) { i++; }
+					return (int)(i-1);
+				}
+			}
+			/* now do a binary search between them */
+			while(j - i > 1) {
+				uint m = (i + j) / 2;
+				if(GetInt((int)m).V.TtIsNil()) { j = m; }
+				else { i = m; }
+			}
+			return (int)i;
+		}
+	}
+}