/* }====================================================== */
private static void AuxOpen(LuaState L, CharPtr name,
LuaNativeFunction f, LuaNativeFunction u)
{
LuaPushCFunction(L, u);
LuaPushCClosure(L, f, 1);
LuaSetField(L, -2, name);
}
public static void lua_pushcfunction(lua_State L, LuaNativeFunction function)
{
#if SAVE_FUNC
savedFn.TryAdd(function);
#endif
lua_pushcclosure(L, function.ToFunctionPointer(), 0);
}
private SharpClass CreateClass(Type classType, Type superType, SharpClass module)
{
string name = GetTableName(classType);
LuaNativeFunction dctor = null;
if (classType.IsValueType)
{
if (!classType.IsUnManaged()) //未注册Wrap，用反射版api， UnmanagedType同Object
{
dctor = gcFn;
}
}
else
{
dctor = gcFn;
}
LuaRef meta = CreateClass(module.Meta, name, classType, superType, dctor);
var bindClass = new SharpClass(module, meta);
bindClass.Name = name;
bindClass.SetClassType(classType);
registeredClass.Add(classType, bindClass);
return(bindClass);
}
private static int RunFunctionDelegate(LuaState luaState, ObjectTranslator translator)
{
LuaNativeFunction func = (LuaNativeFunction)translator.GetRawNetObject(luaState, 1);
LuaLib.LuaRemove(luaState, 1);
return(func(luaState));
}
public static LuaRef CreateFunction(lua_State L, LuaNativeFunction proc, object obj)
{
GCHandle gC = GCHandle.Alloc(obj);
lua_pushlightuserdata(L, GCHandle.ToIntPtr(gC));
lua_pushcclosure(L, proc, 1);
return(PopFromStack(L));
}
public static LuaNativeFunction lua_atpanic(lua_State L, LuaNativeFunction panicFunction)
{
#if SAVE_FUNC
savedFn.TryAdd(panicFunction);
#endif
IntPtr newPanicPtr = panicFunction.ToFunctionPointer();
return(lua_atpanic(L, newPanicPtr).ToLuaFunction());
}
public static LuaNativeFunction LuaAtPanic(LuaState L, LuaNativeFunction panicf)
{
LuaNativeFunction old;
LuaLock(L);
old = G(L).panic;
G(L).panic = panicf;
LuaUnlock(L);
return old;
}
public Lua()
{
luaState = LuaLib.LuaLNewState(); // steffenj: Lua 5.1.1 API change (lua_open is gone)
LuaLib.LuaLOpenLibs(luaState); // steffenj: Lua 5.1.1 API change (luaopen_base is gone, just open all libs right here)
Init();
// We need to keep this in a managed reference so the delegate doesn't get garbage collected
panicCallback = new LuaNativeFunction(PanicCallback);
LuaLib.LuaAtPanic(luaState, panicCallback);
}
public Lua()
{
luaState = LuaLib.LuaLNewState();
LuaLib.LuaLOpenLibs(luaState);
Init();
// We need to keep this in a managed reference so the delegate doesn't get garbage collected
panicCallback = new LuaNativeFunction(PanicCallback);
LuaLib.LuaAtPanic(luaState, panicCallback);
}
public void RegFunction(string name, LuaNativeFunction func)
{
if (!TryGetValue(name, out var methodWraper))
{
methodWraper = new MethodWraper();
Add(name, methodWraper);
}
methodWraper.func = func;
}
public static LuaNativeFunction LuaAtPanic(LuaState L, LuaNativeFunction panicf)
{
LuaNativeFunction old;
LuaLock(L);
old = G(L).panic;
G(L).panic = panicf;
LuaUnlock(L);
return(old);
}
public static void lua_register(lua_State L, string n, LuaNativeFunction f)
{
#if SAVE_FUNC
savedFn.TryAdd(f);
#endif
lua_pushcfunction(L, (f));
var p = Marshal.StringToHGlobalAnsi(n);
lua_setglobal(L, (byte *)(p));
Marshal.FreeHGlobal(p);
}
/*
* Registers an object's method as a Lua function (global or table field)
* The method may have any signature
*/
public LuaFunction RegisterFunction(string path, LuaNativeFunction function)
{
int oldTop = LuaLib.LuaGetTop(luaState);
translator.Push(luaState, function);
this[path] = translator.GetObject(luaState, -1);
var f = GetFunction(path);
LuaLib.LuaSetTop(luaState, oldTop);
return(f);
}
public void RegProperty(string name, LuaNativeFunction getter, LuaNativeFunction setter = null)
{
if (!TryGetValue(name, out var methodWraper))
{
methodWraper = new MethodWraper();
Add(name, methodWraper);
}
methodWraper.getter = getter;
methodWraper.setter = setter;
}
public static LuaNativeFunction LuaToCFunction(IntPtr luaState, int index)
{
IntPtr ptr = NativeMethods.LuaToCFunction(luaState, index);
if (ptr == IntPtr.Zero)
{
return(null);
}
LuaNativeFunction function = Marshal.GetDelegateForFunctionPointer(ptr, typeof(LuaNativeFunction)) as LuaNativeFunction;
return(function);
}
/// <summary>
/// Registers the given function to the current table on the stack top.
/// </summary>
/// <param name="state"></param>
/// <param name="name"></param>
/// <param name="func"></param>
public static void RegisterTableFunction(this NLua.Lua state, string name, LuaNativeFunction func)
{
// Do not continue if we are not a table..
var isTable = NLua.LuaLib.LuaType(state.GetState(), -1) == LuaTypes.Table;
if (!isTable)
return;
// Push the name, function, and set the table..
NLua.LuaLib.LuaPushString(state.GetState(), name);
NLua.LuaLib.LuaPushStdCallCFunction(state.GetState(), func);
NLua.LuaLib.LuaRawSet(state.GetState(), -3);
}
public static int LuaCPCall(LuaState L, LuaNativeFunction func, object ud)
{
CCallS c = new CCallS();
int status;
LuaLock(L);
c.func = func;
c.ud = ud;
status = LuaDPCall(L, FunctionCCall, c, SaveStack(L, L.top), 0);
LuaUnlock(L);
return(status);
}
public static void lua_pushcclosure(lua_State L, LuaNativeFunction function, int n)
{
//Delegate
if (!function.Method.IsDefined(typeof(AOT.MonoPInvokeCallbackAttribute), false))
{
assert(false);
}
#if SAVE_FUNC
savedFn.TryAdd(function);
#endif
lua_pushcclosure(L, function.ToFunctionPointer(), n);
}
public MetaFunctions(ObjectTranslator translator)
{
this.translator = translator;
gcFunction = new LuaNativeFunction(MetaFunctions.CollectObject);
toStringFunction = new LuaNativeFunction(MetaFunctions.ToStringLua);
indexFunction = new LuaNativeFunction(MetaFunctions.GetMethod);
newindexFunction = new LuaNativeFunction(MetaFunctions.SetFieldOrProperty);
baseIndexFunction = new LuaNativeFunction(MetaFunctions.GetBaseMethod);
callConstructorFunction = new LuaNativeFunction(MetaFunctions.CallConstructor);
classIndexFunction = new LuaNativeFunction(MetaFunctions.GetClassMethod);
classNewindexFunction = new LuaNativeFunction(MetaFunctions.SetClassFieldOrProperty);
execDelegateFunction = new LuaNativeFunction(MetaFunctions.RunFunctionDelegate);
}
public static IntPtr ToFunctionPointer(this LuaNativeFunction d)
{
if (d == null)
{
return(IntPtr.Zero);
}
#if NETFRAMEWORK
return(Marshal.GetFunctionPointerForDelegate(d));
#else
return(Marshal.GetFunctionPointerForDelegate <LuaNativeFunction>(d));
#endif
}
/// <summary>
/// Creates and saves reference to function, so it's not garbage
/// collected.
/// </summary>
/// <param name="function"></param>
public static LuaNativeFunction CreateFunctionReference(IntPtr L, LuaNativeFunction function)
{
if (!_functions.TryGetValue(L, out List <LuaNativeFunction> list) || list == null)
{
list = _functions[L] = new List <LuaNativeFunction>();
}
var func = new LuaNativeFunction(function);
list.Add(func);
return(func);
}
public MetaFunctions (ObjectTranslator translator)
{
this.translator = translator;
gcFunction = new LuaNativeFunction (MetaFunctions.CollectObject);
toStringFunction = new LuaNativeFunction (MetaFunctions.ToStringLua);
indexFunction = new LuaNativeFunction (MetaFunctions.GetMethod);
newindexFunction = new LuaNativeFunction (MetaFunctions.SetFieldOrProperty);
baseIndexFunction = new LuaNativeFunction (MetaFunctions.GetBaseMethod);
callConstructorFunction = new LuaNativeFunction (MetaFunctions.CallConstructor);
classIndexFunction = new LuaNativeFunction (MetaFunctions.GetClassMethod);
classNewindexFunction = new LuaNativeFunction (MetaFunctions.SetClassFieldOrProperty);
execDelegateFunction = new LuaNativeFunction (MetaFunctions.RunFunctionDelegate);
}
/*
* Constructs the wrapper for a known MethodBase instance
*/
public LuaMethodWrapper (ObjectTranslator translator, object target, ProxyType targetType, MethodBase method)
{
invokeFunction = new LuaNativeFunction (this.Call);
_Translator = translator;
_Target = target;
if (targetType != null)
_ExtractTarget = translator.typeChecker.GetExtractor (targetType);
_Method = method;
_MethodName = method.Name;
_IsStatic = method.IsStatic;
}
/// <summary>
/// Constructs the wrapper for a known method name
/// </summary>
/// <param name="translator"></param>
/// <param name="targetType"></param>
/// <param name="methodName"></param>
/// <param name="bindingType"></param>
public LuaMethodWrapper(ObjectTranslator translator, IReflect targetType, string methodName, BindingFlags bindingType)
{
invokeFunction = new LuaNativeFunction(this.Call);
_Translator = translator;
_MethodName = methodName;
if (targetType != null)
_ExtractTarget = translator.typeChecker.GetExtractor(targetType);
_BindingType = bindingType;
//CP: Removed NonPublic binding search and added IgnoreCase
_Members = targetType.UnderlyingSystemType.GetMember(methodName, MemberTypes.Method, bindingType | BindingFlags.Public | BindingFlags.IgnoreCase/*|BindingFlags.NonPublic*/);
}
/// <summary>
/// Creates a function reference to a function and stores it in <see cref="Functions"/>.
/// </summary>
public static LuaNativeFunction GetFunctionRef(IntPtr L, LuaNativeFunction function)
{
List <LuaNativeFunction> list;
if (!Functions.TryGetValue(L, out list) || list == null)
{
list = Functions[L] = new List <LuaNativeFunction>();
}
var func = new LuaNativeFunction(function);
list.Add(func);
return(func);
}
/*
* Constructs the wrapper for a known method name
*/
public LuaMethodWrapper(ObjectTranslator translator, ProxyType targetType, string methodName, BindingFlags bindingType)
{
invokeFunction = new LuaNativeFunction(this.Call);
_Translator = translator;
_MethodName = methodName;
if (targetType != null)
{
_ExtractTarget = translator.typeChecker.GetExtractor(targetType);
}
_BindingType = bindingType;
_Members = targetType.UnderlyingSystemType.GetMember(methodName, MemberTypes.Method, bindingType | BindingFlags.Public);
}
public static LuaNativeFunction LuaToCFunction(IntPtr luaState, int index)
{
IntPtr ptr = NativeMethods.LuaToCFunction(luaState, index);
if (ptr == IntPtr.Zero)
{
return(null);
}
#if NETFX_CORE
LuaNativeFunction function = Marshal.GetDelegateForFunctionPointer <LuaNativeFunction> (ptr);
#else
LuaNativeFunction function = Marshal.GetDelegateForFunctionPointer(ptr, typeof(LuaNativeFunction)) as LuaNativeFunction;
#endif
return(function);
}
/*
* Constructs the wrapper for a known method name
*/
public LuaMethodWrapper(ObjectTranslator translator, ProxyType targetType, string methodName, BindingFlags bindingType)
{
invokeFunction = new LuaNativeFunction(this.Call);
_Translator = translator;
_MethodName = methodName;
if (targetType != null)
{
_ExtractTarget = translator.typeChecker.GetExtractor(targetType);
}
_IsStatic = (bindingType & BindingFlags.Static) == BindingFlags.Static;
_Members = GetMethodsRecursively(targetType.UnderlyingSystemType, methodName, bindingType | BindingFlags.Public);
}
/*
* Constructs the wrapper for a known MethodBase instance
*/
public LuaMethodWrapper(ObjectTranslator translator, object target, ProxyType targetType, MethodBase method)
{
invokeFunction = new LuaNativeFunction(this.Call);
_Translator = translator;
_Target = target;
if (targetType != null)
{
_ExtractTarget = translator.typeChecker.GetExtractor(targetType);
}
_Method = method;
_MethodName = method.Name;
_IsStatic = method.IsStatic;
}
/*
* Constructs the wrapper for a known method name
*/
public LuaMethodWrapper(ObjectTranslator translator, IReflect targetType, string methodName, BindingFlags bindingType)
{
invokeFunction = new LuaNativeFunction(this.Call);
_Translator = translator;
_MethodName = methodName;
if (targetType != null)
{
_ExtractTarget = translator.typeChecker.GetExtractor(targetType);
}
_BindingType = bindingType;
//CP: Removed NonPublic binding search and added IgnoreCase
_Members = targetType.UnderlyingSystemType.GetMember(methodName, MemberTypes.Method, bindingType | BindingFlags.Public | BindingFlags.IgnoreCase /*|BindingFlags.NonPublic*/);
}
public void AddSearcher(LuaNativeFunction searcher)
{
var state = State;
lua_getglobal(L, "package");
lua_getfield(L, -1, "searchers");
lua_pushcfunction(L, searcher);
for (long i = luaL_len(L, -2) + 1; i > 2; i--)
{
lua_rawgeti(L, -2, i - 1);
lua_rawseti(L, -3, i);
}
lua_rawseti(L, -2, 2);
lua_pop(L, 2);
}
/*
* Constructs the wrapper for a known MethodBase instance
*/
public LuaMethodWrapper (ObjectTranslator translator, object target, IReflect targetType, MethodBase method)
{
invokeFunction = new LuaNativeFunction (this.Call);
_Translator = translator;
_Target = target;
if (targetType != null)
_ExtractTarget = translator.typeChecker.GetExtractor (targetType);
_Method = method;
_MethodName = method.Name;
if (method.IsStatic)
_BindingType = BindingFlags.Static;
else
_BindingType = BindingFlags.Instance;
}
public static void LuaPushCClosure(LuaState L, LuaNativeFunction fn, int n)
{
Closure cl;
LuaLock(L);
LuaCCheckGC(L);
CheckNElements(L, n);
cl = LuaFNewCclosure(L, n, GetCurrentEnv(L));
cl.c.f = fn;
L.top -= n;
while (n-- != 0)
{
SetObj2N(L, cl.c.upvalue[n], L.top + n);
}
SetCLValue(L, L.top, cl);
LuaAssert(IsWhite(obj2gco(cl)));
IncrementTop(L);
LuaUnlock(L);
}
public ObjectTranslator(Lua interpreter, LuaState luaState)
{
this.interpreter = interpreter;
typeChecker = new CheckType(this);
metaFunctions = new MetaFunctions(this);
assemblies = new List <Assembly> ();
importTypeFunction = new LuaNativeFunction(ObjectTranslator.ImportType);
loadAssemblyFunction = new LuaNativeFunction(ObjectTranslator.LoadAssembly);
registerTableFunction = new LuaNativeFunction(ObjectTranslator.RegisterTable);
unregisterTableFunction = new LuaNativeFunction(ObjectTranslator.UnregisterTable);
getMethodSigFunction = new LuaNativeFunction(ObjectTranslator.GetMethodSignature);
getConstructorSigFunction = new LuaNativeFunction(ObjectTranslator.GetConstructorSignature);
CreateLuaObjectList(luaState);
CreateIndexingMetaFunction(luaState);
CreateBaseClassMetatable(luaState);
CreateClassMetatable(luaState);
CreateFunctionMetatable(luaState);
SetGlobalFunctions(luaState);
}
/*
* Constructs the wrapper for a known MethodBase instance
*/
public LuaMethodWrapper(ObjectTranslator translator, object target, IReflect targetType, MethodBase method)
{
invokeFunction = new LuaNativeFunction(this.Call);
_Translator = translator;
_Target = target;
if (targetType != null)
{
_ExtractTarget = translator.typeChecker.GetExtractor(targetType);
}
_Method = method;
_MethodName = method.Name;
if (method.IsStatic)
{
_BindingType = BindingFlags.Static;
}
else
{
_BindingType = BindingFlags.Instance;
}
}
public ObjectTranslator(Lua interpreter, LuaState luaState)
{
this.interpreter = interpreter;
typeChecker = new CheckType(this);
metaFunctions = new MetaFunctions(this);
assemblies = new List<Assembly>();
importTypeFunction = new LuaNativeFunction(ObjectTranslator.ImportType);
loadAssemblyFunction = new LuaNativeFunction(ObjectTranslator.LoadAssembly);
registerTableFunction = new LuaNativeFunction(ObjectTranslator.RegisterTable);
unregisterTableFunction = new LuaNativeFunction(ObjectTranslator.UnregisterTable);
getMethodSigFunction = new LuaNativeFunction(ObjectTranslator.GetMethodSignature);
getConstructorSigFunction = new LuaNativeFunction(ObjectTranslator.GetConstructorSignature);
ctypeFunction = new LuaNativeFunction(ObjectTranslator.CType);
enumFromIntFunction = new LuaNativeFunction(ObjectTranslator.EnumFromInt);
CreateLuaObjectList(luaState);
CreateIndexingMetaFunction(luaState);
CreateBaseClassMetatable(luaState);
CreateClassMetatable(luaState);
CreateFunctionMetatable(luaState);
SetGlobalFunctions(luaState);
}
public static void LuaPushCFunction(LuaState L, LuaNativeFunction f)
{
LuaPushCClosure(L, f, 0);
}
public static void LuaRegister(LuaState L, CharPtr n, LuaNativeFunction f)
{
LuaPushCFunction(L, f);
LuaSetGlobal(L, n);
}
public static void LuaPushCClosure(LuaState L, LuaNativeFunction fn, int n)
{
Closure cl;
LuaLock(L);
LuaCCheckGC(L);
CheckNElements(L, n);
cl = LuaFNewCclosure(L, n, GetCurrentEnv(L));
cl.c.f = fn;
L.top -= n;
while (n-- != 0)
SetObj2N(L, cl.c.upvalue[n], L.top + n);
SetCLValue(L, L.top, cl);
LuaAssert(IsWhite(obj2gco(cl)));
IncrementTop(L);
LuaUnlock(L);
}
public LuaFunction (int reference, Lua interpreter)
{
_Reference = reference;
this.function = null;
_Interpreter = interpreter;
}
public Lua ()
{
luaState = LuaLib.LuaLNewState (); // steffenj: Lua 5.1.1 API change (lua_open is gone)
LuaLib.LuaLOpenLibs (luaState); // steffenj: Lua 5.1.1 API change (luaopen_base is gone, just open all libs right here)
Init ();
// We need to keep this in a managed reference so the delegate doesn't get garbage collected
panicCallback = new LuaNativeFunction (PanicCallback);
LuaLib.LuaAtPanic (luaState, panicCallback);
}
public static void LuaAtPanic (IntPtr luaState, LuaNativeFunction panicf)
{
IntPtr fnpanic = Marshal.GetFunctionPointerForDelegate (panicf);
NativeMethods.LuaAtPanic (luaState, fnpanic);
}
/*
* Constructs the wrapper for a known method name
*/
public LuaMethodWrapper (ObjectTranslator translator, IReflect targetType, string methodName, BindingFlags bindingType)
{
invokeFunction = new LuaNativeFunction (this.Call);
_Translator = translator;
_MethodName = methodName;
if (targetType != null)
_ExtractTarget = translator.typeChecker.GetExtractor (targetType);
_BindingType = bindingType;
_Members = targetType.UnderlyingSystemType.GetMember (methodName, MemberTypes.Method, bindingType | BindingFlags.Public);
}
public static void LuaPushStdCallCFunction(LuaState luaState, LuaNativeFunction function)
{
LuaPushCFunction (luaState, function);
}
public LuaLReg(CharPtr name, LuaNativeFunction func) {
this.name = name;
this.func = func;
}
/* }====================================================== */
private static void AuxOpen(LuaState L, CharPtr name,
LuaNativeFunction f, LuaNativeFunction u)
{
LuaPushCFunction(L, u);
LuaPushCClosure(L, f, 1);
LuaSetField(L, -2, name);
}
public static void LuaAtPanic (LuaState luaState, LuaNativeFunction panicf)
{
LuaCore.LuaAtPanic (luaState, (LuaNativeFunction)panicf);
}
/*
* Constructs the wrapper for a known method name
*/
public LuaMethodWrapper (ObjectTranslator translator, ProxyType targetType, string methodName, BindingFlags bindingType)
{
invokeFunction = new LuaNativeFunction (this.Call);
_Translator = translator;
_MethodName = methodName;
if (targetType != null)
_ExtractTarget = translator.typeChecker.GetExtractor (targetType);
_IsStatic = (bindingType & BindingFlags.Static) == BindingFlags.Static;
_Members = GetMethodsRecursively (targetType.UnderlyingSystemType, methodName, bindingType | BindingFlags.Public);
}
public static int LuaCPCall(LuaState L, LuaNativeFunction func, object ud)
{
CCallS c = new CCallS();
int status;
LuaLock(L);
c.func = func;
c.ud = ud;
status = LuaDPCall(L, FunctionCCall, c, SaveStack(L, L.top), 0);
LuaUnlock(L);
return status;
}
/*
* Pushes a delegate into the stack
*/
internal void PushFunction(LuaState luaState, LuaNativeFunction func)
{
PushObject(luaState, func, "luaNet_function");
}
public LuaFunction (LuaNativeFunction function, Lua interpreter)
{
_Reference = 0;
this.function = function;
_Interpreter = interpreter;
}
private static void NewFEnv(LuaState L, LuaNativeFunction cls)
{
LuaCreateTable(L, 0, 1);
LuaPushCFunction(L, cls);
LuaSetField(L, -2, "__close");
}
int GetExtensionMethod (LuaState luaState, Type type, object obj, string name)
{
object cachedMember = CheckMemberCache (memberCache, type, name);
if (cachedMember != null && cachedMember is LuaNativeFunction) {
translator.PushFunction (luaState, (LuaNativeFunction)cachedMember);
translator.Push (luaState, true);
return 2;
}
MethodInfo methodInfo = translator.GetExtensionMethod (type, name);
var wrapper = new LuaNativeFunction ((new LuaMethodWrapper (translator, obj, type, methodInfo)).invokeFunction);
SetMemberCache (memberCache, type, name, wrapper);
translator.PushFunction (luaState, wrapper);
translator.Push (luaState, true);
return 2;
}
internal void PushCSFunction (LuaNativeFunction function)
{
translator.PushFunction (luaState, function);
}
/*
* Pushes the value of a member or a delegate to call it, depending on the type of
* the member. Works with static or instance members.
* Uses reflection to find members, and stores the reflected MemberInfo object in
* a cache (indexed by the type of the object and the name of the member).
*/
int GetMember (LuaState luaState, IReflect objType, object obj, string methodName, BindingFlags bindingType)
{
bool implicitStatic = false;
MemberInfo member = null;
object cachedMember = CheckMemberCache (memberCache, objType, methodName);
if (cachedMember is LuaNativeFunction) {
translator.PushFunction (luaState, (LuaNativeFunction)cachedMember);
translator.Push (luaState, true);
return 2;
} else if (cachedMember != null)
member = (MemberInfo)cachedMember;
else {
var members = objType.GetMember (methodName, bindingType | BindingFlags.Public);
if (members.Length > 0)
member = members [0];
else {
// If we can't find any suitable instance members, try to find them as statics - but we only want to allow implicit static
members = objType.GetMember (methodName, bindingType | BindingFlags.Static | BindingFlags.Public);
if (members.Length > 0) {
member = members [0];
implicitStatic = true;
}
}
}
if (member != null) {
if (member.MemberType == MemberTypes.Field) {
var field = (FieldInfo)member;
if (cachedMember == null)
SetMemberCache (memberCache, objType, methodName, member);
try {
translator.Push (luaState, field.GetValue (obj));
} catch {
LuaLib.LuaPushNil (luaState);
}
} else if (member.MemberType == MemberTypes.Property) {
var property = (PropertyInfo)member;
if (cachedMember == null)
SetMemberCache (memberCache, objType, methodName, member);
try {
object val = property.GetValue (obj, null);
translator.Push (luaState, val);
} catch (ArgumentException) {
// If we can't find the getter in our class, recurse up to the base class and see
// if they can help.
if (objType is Type && !(((Type)objType) == typeof(object)))
return GetMember (luaState, ((Type)objType).BaseType, obj, methodName, bindingType);
else
LuaLib.LuaPushNil (luaState);
} catch (TargetInvocationException e) { // Convert this exception into a Lua error
ThrowError (luaState, e);
LuaLib.LuaPushNil (luaState);
}
} else if (member.MemberType == MemberTypes.Event) {
var eventInfo = (EventInfo)member;
if (cachedMember == null)
SetMemberCache (memberCache, objType, methodName, member);
translator.Push (luaState, new RegisterEventHandler (translator.pendingEvents, obj, eventInfo));
} else if (!implicitStatic) {
if (member.MemberType == MemberTypes.NestedType) {
// kevinh - added support for finding nested types
// cache us
if (cachedMember == null)
SetMemberCache (memberCache, objType, methodName, member);
// Find the name of our class
string name = member.Name;
var dectype = member.DeclaringType;
// Build a new long name and try to find the type by name
string longname = dectype.FullName + "+" + name;
var nestedType = translator.FindType (longname);
translator.PushType (luaState, nestedType);
} else {
// Member type must be 'method'
var wrapper = new LuaNativeFunction ((new LuaMethodWrapper (translator, objType, methodName, bindingType)).invokeFunction);
if (cachedMember == null)
SetMemberCache (memberCache, objType, methodName, wrapper);
translator.PushFunction (luaState, wrapper);
translator.Push (luaState, true);
return 2;
}
} else {
// If we reach this point we found a static method, but can't use it in this context because the user passed in an instance
translator.ThrowError (luaState, "can't pass instance to static method " + methodName);
LuaLib.LuaPushNil (luaState);
}
} else {
// kevinh - we want to throw an exception because meerly returning 'nil' in this case
// is not sufficient. valid data members may return nil and therefore there must be some
// way to know the member just doesn't exist.
translator.ThrowError (luaState, "unknown member name " + methodName);
LuaLib.LuaPushNil (luaState);
}
// push false because we are NOT returning a function (see luaIndexFunction)
translator.Push (luaState, false);
return 2;
}
/*
* Pushes a delegate into the stack
*/
internal void PushFunction (LuaState luaState, LuaNativeFunction func)
{
PushObject (luaState, func, "luaNet_function");
}
public MetaFunctions (ObjectTranslator translator)
{
this.translator = translator;
GcFunction = new LuaNativeFunction (MetaFunctions.CollectObject);
ToStringFunction = new LuaNativeFunction (MetaFunctions.ToStringLua);
IndexFunction = new LuaNativeFunction (MetaFunctions.GetMethod);
NewIndexFunction = new LuaNativeFunction (MetaFunctions.SetFieldOrProperty);
BaseIndexFunction = new LuaNativeFunction (MetaFunctions.GetBaseMethod);
CallConstructorFunction = new LuaNativeFunction (MetaFunctions.CallConstructor);
ClassIndexFunction = new LuaNativeFunction (MetaFunctions.GetClassMethod);
ClassNewindexFunction = new LuaNativeFunction (MetaFunctions.SetClassFieldOrProperty);
ExecuteDelegateFunction = new LuaNativeFunction (MetaFunctions.RunFunctionDelegate);
AddFunction = new LuaNativeFunction (MetaFunctions.AddLua);
SubtractFunction = new LuaNativeFunction (MetaFunctions.SubtractLua);
MultiplyFunction = new LuaNativeFunction (MetaFunctions.MultiplyLua);
DivisionFunction = new LuaNativeFunction (MetaFunctions.DivideLua);
ModulosFunction = new LuaNativeFunction (MetaFunctions.ModLua);
UnaryNegationFunction = new LuaNativeFunction (MetaFunctions.UnaryNegationLua);
EqualFunction = new LuaNativeFunction (MetaFunctions.EqualLua);
LessThanFunction = new LuaNativeFunction (MetaFunctions.LessThanLua);
LessThanOrEqualFunction = new LuaNativeFunction (MetaFunctions.LessThanOrEqualLua);
}
public static void LuaPushStdCallCFunction (IntPtr luaState, LuaNativeFunction fn)
{
IntPtr pfunc = Marshal.GetFunctionPointerForDelegate (fn);
NativeMethods.LuaPushStdCallCFunction (luaState, pfunc);
}
public Lua ()
{
luaState = LuaLib.LuaLNewState ();
LuaLib.LuaLOpenLibs (luaState);
Init ();
// We need to keep this in a managed reference so the delegate doesn't get garbage collected
panicCallback = new LuaNativeFunction (PanicCallback);
LuaLib.LuaAtPanic (luaState, panicCallback);
}
