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); }