protected static void AddMember(IntPtr ptr, string name, LuaCSFunction get, LuaCSFunction set, bool instance)
{
CheckMethodValid(get);
CheckMethodValid(set);
int t = instance ? -2 : -3;
LuaNativeMethods.lua_createtable(ptr, 2, 0);
if (get == null)
{
LuaNativeMethods.lua_pushnil(ptr);
}
else
{
PushValue(ptr, get);
}
LuaNativeMethods.lua_rawseti(ptr, -2, 1);
if (set == null)
{
LuaNativeMethods.lua_pushnil(ptr);
}
else
{
PushValue(ptr, set);
}
LuaNativeMethods.lua_rawseti(ptr, -2, 2);
LuaNativeMethods.lua_setfield(ptr, t, name);
}
public static int GetOpFunction(IntPtr ptr, string f, string tip)
{
int err = PushTry(ptr);
CheckLuaObject(ptr, 1);
while (!LuaNativeMethods.lua_isnil(ptr, -1))
{
LuaNativeMethods.lua_getfield(ptr, -1, f);
if (!LuaNativeMethods.lua_isnil(ptr, -1))
{
LuaNativeMethods.lua_remove(ptr, -2);
break;
}
LuaNativeMethods.lua_pop(ptr, 1); // pop nil
LuaNativeMethods.lua_getfield(ptr, -1, "__parent");
LuaNativeMethods.lua_remove(ptr, -2); // pop base
}
if (LuaNativeMethods.lua_isnil(ptr, -1))
{
LuaNativeMethods.lua_pop(ptr, 1);
throw new Exception(string.Format("No {0} operator", tip));
}
return(err);
}
public static int Error(IntPtr ptr, string err, params object[] args)
{
err = string.Format(err, args);
LuaNativeMethods.lua_pushboolean(ptr, false);
LuaNativeMethods.lua_pushstring(ptr, err);
return(2);
}
public static bool CheckType(IntPtr ptr, int p, out LuaDelegate f)
{
LuaState state = LuaState.Get(ptr);
p = LuaNativeMethods.lua_absindex(ptr, p);
LuaNativeMethods.luaL_checktype(ptr, p, LuaTypes.TYPE_FUNCTION);
LuaNativeMethods.lua_getglobal(ptr, DelgateTable);
LuaNativeMethods.lua_pushvalue(ptr, p);
LuaNativeMethods.lua_gettable(ptr, -2); // find function in __LuaDelegate table
if (LuaNativeMethods.lua_isnil(ptr, -1))
{ // not found
LuaNativeMethods.lua_pop(ptr, 1); // pop nil
f = NewDelegate(ptr, p);
}
else
{
int fref = LuaNativeMethods.lua_tointeger(ptr, -1);
LuaNativeMethods.lua_pop(ptr, 1); // pop ref value;
f = state.DelegateMap[fref];
if (f == null)
{
f = NewDelegate(ptr, p);
}
}
LuaNativeMethods.lua_pop(ptr, 1); // pop DelgateTable
return(true);
}
public static LuaState Get(IntPtr ptr)
{
if (ptr == oldptr)
{
return(oldstate);
}
LuaState ls;
if (statemap.TryGetValue(ptr, out ls))
{
oldptr = ptr;
oldstate = ls;
return(ls);
}
LuaNativeMethods.lua_getglobal(ptr, "__main_state");
if (LuaNativeMethods.lua_isnil(ptr, -1))
{
LuaNativeMethods.lua_pop(ptr, 1);
return(null);
}
IntPtr nl = LuaNativeMethods.lua_touserdata(ptr, -1);
LuaNativeMethods.lua_pop(ptr, 1);
if (nl != ptr)
{
return(Get(nl));
}
return(null);
}
public bool InnerCall(int args, int errfunc)
{
bool ret = ProtectedCall(args, errfunc);
LuaNativeMethods.lua_remove(VariablePointer, errfunc);
return(ret);
}
public bool MoveNext()
{
if (tableIndex < 0)
{
return(false);
}
if (iterPhase == 0)
{
LuaNativeMethods.lua_pushnil(table.VariablePointer);
iterPhase = 1;
}
else
{
LuaNativeMethods.lua_pop(table.VariablePointer, 1);
}
// var ty = LuaDLL.lua_type(t.L, -1);
bool ret = LuaNativeMethods.lua_next(table.VariablePointer, tableIndex) > 0;
if (!ret)
{
iterPhase = 2;
}
return(ret);
}
public object TopObjects(int from)
{
int top = LuaNativeMethods.lua_gettop(statePointer);
int args = top - from;
if (args == 0)
{
return(null);
}
else if (args == 1)
{
object o = LuaObject.CheckVar(statePointer, top);
LuaNativeMethods.lua_pop(statePointer, 1);
return(o);
}
else
{
object[] o = new object[args];
for (int n = 1; n <= args; n++)
{
o[n - 1] = LuaObject.CheckVar(statePointer, from + n);
}
LuaNativeMethods.lua_settop(statePointer, from);
return(o);
}
}
public bool ProtectedCall(int args, int errfunc)
{
if (!state.IsMainThread())
{
Logger.LogError("Can't call lua function in bg thread");
return(false);
}
LuaNativeMethods.lua_getref(VariablePointer, valueref);
if (!LuaNativeMethods.lua_isfunction(VariablePointer, -1))
{
LuaNativeMethods.lua_pop(VariablePointer, 1);
throw new Exception("Call invalid function.");
}
LuaNativeMethods.lua_insert(VariablePointer, -args - 1);
if (LuaNativeMethods.lua_pcall(VariablePointer, args, -1, errfunc) != 0)
{
LuaNativeMethods.lua_pop(VariablePointer, 1);
return(false);
}
return(true);
}
public static ObjectCache Get(IntPtr ptr)
{
if (oldPtr == ptr)
{
return(Oldoc);
}
ObjectCache oc;
if (multiState.TryGetValue(ptr, out oc))
{
oldPtr = ptr;
Oldoc = oc;
return(oc);
}
LuaNativeMethods.lua_getglobal(ptr, "__main_state");
if (LuaNativeMethods.lua_isnil(ptr, -1))
{
LuaNativeMethods.lua_pop(ptr, 1);
return(null);
}
IntPtr nl = LuaNativeMethods.lua_touserdata(ptr, -1);
LuaNativeMethods.lua_pop(ptr, 1);
if (nl != ptr)
{
return(Get(nl));
}
return(null);
}
public static void PushVar(IntPtr ptr, object o)
{
if (o == null)
{
LuaNativeMethods.lua_pushnil(ptr);
return;
}
Type t = o.GetType();
LuaState.PushVarDelegate push;
LuaState ls = LuaState.Get(ptr);
if (ls.TryGetTypePusher(t, out push))
{
push(ptr, o);
}
else if (t.IsEnum)
{
PushEnum(ptr, Convert.ToInt32(o));
}
else if (t.IsArray)
{
PushObject(ptr, (Array)o);
}
else
{
PushObject(ptr, o);
}
}
public static void CompleteTypeMeta(IntPtr ptr, LuaCSFunction con, Type self)
{
LuaNativeMethods.lua_pushstring(ptr, ObjectCache.GetAQName(self));
LuaNativeMethods.lua_setfield(ptr, -3, "__fullname");
indexFunction.Push(ptr);
LuaNativeMethods.lua_setfield(ptr, -2, "__index");
newIndexFunction.Push(ptr);
LuaNativeMethods.lua_setfield(ptr, -2, "__newindex");
if (con == null)
{
con = NoConstructor;
}
PushValue(ptr, con);
LuaNativeMethods.lua_setfield(ptr, -2, "__call");
LuaNativeMethods.lua_pushcfunction(ptr, TypeToString);
LuaNativeMethods.lua_setfield(ptr, -2, "__tostring");
LuaNativeMethods.lua_pushvalue(ptr, -1);
LuaNativeMethods.lua_setmetatable(ptr, -3);
LuaNativeMethods.lua_setfield(ptr, LuaIndexes.LUARegistryIndex, self.FullName);
}
public static int MakeArray(IntPtr ptr)
{
try
{
Type t;
CheckType(ptr, 1, out t);
LuaNativeMethods.luaL_checktype(ptr, 2, LuaTypes.TYPE_TABLE);
int n = LuaNativeMethods.lua_rawlen(ptr, 2);
Array array = Array.CreateInstance(t, n);
for (int k = 0; k < n; k++)
{
LuaNativeMethods.lua_rawgeti(ptr, 2, k + 1);
object obj = LuaObject.CheckVar(ptr, -1);
array.SetValue(LuaObject.ChangeType(obj, t), k);
LuaNativeMethods.lua_pop(ptr, 1);
}
LuaObject.PushValue(ptr, true);
LuaObject.PushValue(ptr, array);
return(2);
}
catch (Exception e)
{
return(Error(ptr, e));
}
}
public static int LuaIndex(IntPtr ptr)
{
try
{
Array a = (Array)CheckSelf(ptr);
if (LuaNativeMethods.lua_type(ptr, 2) == LuaTypes.TYPE_STRING)
{
string mn;
CheckType(ptr, 2, out mn);
ArrayPropFunction fun;
if (propertyMethods.TryGetValue(mn, out fun))
{
LuaObject.PushValue(ptr, true);
return(fun(ptr, a) + 1);
}
else
{
throw new Exception("Can't find property named " + mn);
}
}
else
{
int i;
CheckType(ptr, 2, out i);
LuaObject.Assert(i > 0, "index base 1");
LuaObject.PushValue(ptr, true);
LuaObject.PushVar(ptr, a.GetValue(i - 1));
return(2);
}
}
catch (Exception e)
{
return(Error(ptr, e));
}
}
public static new int ToString(IntPtr ptr)
{
try
{
object o = CheckObj(ptr, 1);
if (o == null)
{
LuaObject.PushValue(ptr, true);
LuaNativeMethods.lua_pushnil(ptr);
return(2);
}
LuaObject.PushValue(ptr, true);
if (o is byte[])
{
byte[] b = (byte[])o;
LuaNativeMethods.lua_pushlstring(ptr, b, b.Length);
}
else
{
LuaObject.PushValue(ptr, o.ToString());
}
return(2);
}
catch (Exception e)
{
return(Error(ptr, e));
}
}
public static bool CheckArray <T>(IntPtr ptr, int p, out T[] ta)
{
if (LuaNativeMethods.lua_type(ptr, p) == LuaTypes.TYPE_TABLE)
{
int n = LuaNativeMethods.lua_rawlen(ptr, p);
ta = new T[n];
for (int k = 0; k < n; k++)
{
LuaNativeMethods.lua_rawgeti(ptr, p, k + 1);
object o = CheckVar(ptr, -1);
Type fromT = o.GetType();
Type toT = typeof(T);
if (toT.IsAssignableFrom(fromT))
{
ta[k] = (T)o;
}
else
{
ta[k] = (T)Convert.ChangeType(o, typeof(T));
}
LuaNativeMethods.lua_pop(ptr, 1);
}
return(true);
}
else
{
Array array = CheckObj(ptr, p) as Array;
ta = array as T[];
return(ta != null);
}
}
public static int Constructor(IntPtr ptr)
{
try
{
int argc = LuaNativeMethods.lua_gettop(ptr);
ByteArray o;
if (argc == 1)
{
o = new ByteArray();
LuaObject.PushValue(ptr, true);
LuaObject.PushValue(ptr, o);
return(2);
}
else if (argc == 2)
{
byte[] a1;
LuaObject.CheckArray(ptr, 2, out a1);
o = new ByteArray(a1);
LuaObject.PushValue(ptr, true);
LuaObject.PushValue(ptr, o);
return(2);
}
return(Error(ptr, "New object failed."));
}
catch (Exception e)
{
return(Error(ptr, e));
}
}
public bool DoBuffer(byte[] bytes, string fn, out object ret)
{
// ensure no utf-8 bom, LuaJIT can read BOM, but Lua cannot!
bytes = CleanUTF8Bom(bytes);
ret = null;
int errfunc = LuaObject.PushTry(statePointer);
if (LuaNativeMethods.luaL_loadbuffer(statePointer, bytes, bytes.Length, fn) == 0)
{
if (LuaNativeMethods.lua_pcall(statePointer, 0, LuaNativeMethods.LUAMultRet, errfunc) != 0)
{
LuaNativeMethods.lua_pop(statePointer, 2);
return(false);
}
LuaNativeMethods.lua_remove(statePointer, errfunc); // pop error function
ret = TopObjects(errfunc - 1);
return(true);
}
string err = LuaNativeMethods.lua_tostring(statePointer, -1);
LuaNativeMethods.lua_pop(statePointer, 2);
throw new Exception("File " + fn + ": " + err);
}
public object GetObject(string key)
{
LuaNativeMethods.lua_pushglobaltable(statePointer);
object o = GetObject(key.Split(new char[] { '.' }));
LuaNativeMethods.lua_pop(statePointer, 1);
return(o);
}
public static void RemoveDelgate(IntPtr ptr, int r)
{
LuaNativeMethods.lua_getglobal(ptr, DelgateTable);
LuaNativeMethods.lua_getref(ptr, r); // push key
LuaNativeMethods.lua_pushnil(ptr); // push nil value
LuaNativeMethods.lua_settable(ptr, -3); // remove function from __LuaDelegate table
LuaNativeMethods.lua_pop(ptr, 1); // pop __LuaDelegate
}
public void SetObject(int reference, string field, object o)
{
int oldTop = LuaNativeMethods.lua_gettop(statePointer);
LuaNativeMethods.lua_getref(statePointer, reference);
SetObject(field.Split(new char[] { '.' }), o);
LuaNativeMethods.lua_settop(statePointer, oldTop);
}
public static void GetTypeTable(IntPtr ptr, string t)
{
NewTypeTable(ptr, t);
// for static
LuaNativeMethods.lua_newtable(ptr);
// for instance
LuaNativeMethods.lua_newtable(ptr);
}
public static bool CheckEnum <T>(IntPtr ptr, int p, out T o) where T : struct
{
int i = (int)LuaNativeMethods.luaL_checkinteger(ptr, p);
o = (T)Enum.ToObject(typeof(T), i);
return(true);
}
public static void PushValue(IntPtr ptr, ulong o)
{
#if LUA_5_3
LuaDLL.lua_pushinteger(ptr, (long)o);
#else
LuaNativeMethods.lua_pushnumber(ptr, o);
#endif
}
public void CheckTop()
{
if (LuaNativeMethods.lua_gettop(StatePointer) != errorReported)
{
errorReported = LuaNativeMethods.lua_gettop(StatePointer);
Logger.LogError(string.Format("Some function not remove temp value({0}) from lua stack. You should fix it.", LuaNativeMethods.luaL_typename(StatePointer, errorReported)));
}
}
public static void PushValue(IntPtr ptr, long i)
{
#if LUA_5_3
LuaDLL.lua_pushinteger(l, i);
#else
LuaNativeMethods.lua_pushnumber(ptr, i);
#endif
}
public ObjectCache(IntPtr ptr)
{
LuaNativeMethods.lua_newtable(ptr);
LuaNativeMethods.lua_newtable(ptr);
LuaNativeMethods.lua_pushstring(ptr, "v");
LuaNativeMethods.lua_setfield(ptr, -2, "__mode");
LuaNativeMethods.lua_setmetatable(ptr, -2);
cacheRef = LuaNativeMethods.luaL_ref(ptr, LuaIndexes.LUARegistryIndex);
}
public static bool CheckType(IntPtr ptr, int p, out ulong v)
{
#if LUA_5_3
v = (ulong)LuaDLL.luaL_checkinteger(ptr, p);
#else
v = (ulong)LuaNativeMethods.luaL_checknumber(ptr, p);
#endif
return(true);
}
public static bool CheckArray(IntPtr ptr, int p, out char[] pars)
{
LuaNativeMethods.luaL_checktype(ptr, p, LuaTypes.TYPE_STRING);
string s;
CheckType(ptr, p, out s);
pars = s.ToCharArray();
return(true);
}
public void Dispose()
{
if (iterPhase == 1)
{
LuaNativeMethods.lua_pop(table.VariablePointer, 2);
}
LuaNativeMethods.lua_remove(table.VariablePointer, tableIndex);
}
