From 55423b159adaa9a7625dc61a093a15e4ad0f3356 Mon Sep 17 00:00:00 2001 From: ScottNZ Date: Fri, 15 Nov 2013 21:53:56 +1300 Subject: [PATCH 01/18] Move RASpecialPowers into OpenRA.Mods.RA.Scripting --- OpenRA.Mods.RA/Missions/DesertShellmapScript.cs | 2 +- OpenRA.Mods.RA/Scripting/RASpecialPowers.cs | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/OpenRA.Mods.RA/Missions/DesertShellmapScript.cs b/OpenRA.Mods.RA/Missions/DesertShellmapScript.cs index e457896675..8fe61fd133 100644 --- a/OpenRA.Mods.RA/Missions/DesertShellmapScript.cs +++ b/OpenRA.Mods.RA/Missions/DesertShellmapScript.cs @@ -16,7 +16,7 @@ using OpenRA.Mods.RA.Activities; using OpenRA.Mods.RA.Air; using OpenRA.Mods.RA.Buildings; using OpenRA.Mods.RA.Move; -using OpenRA.Scripting; +using OpenRA.Mods.RA.Scripting; using OpenRA.Traits; namespace OpenRA.Mods.RA.Missions diff --git a/OpenRA.Mods.RA/Scripting/RASpecialPowers.cs b/OpenRA.Mods.RA/Scripting/RASpecialPowers.cs index 304e7f8176..bd044cf7d8 100644 --- a/OpenRA.Mods.RA/Scripting/RASpecialPowers.cs +++ b/OpenRA.Mods.RA/Scripting/RASpecialPowers.cs @@ -10,9 +10,8 @@ using System.Collections.Generic; using OpenRA.FileFormats; -using OpenRA.Mods.RA; -namespace OpenRA.Scripting +namespace OpenRA.Mods.RA.Scripting { public class RASpecialPowers { From 0a50371a377c3e3cc9726cc0003abd6a596ed746 Mon Sep 17 00:00:00 2001 From: ScottNZ Date: Fri, 15 Nov 2013 21:55:38 +1300 Subject: [PATCH 02/18] Add LuaInterface project --- AUTHORS | 3 + LuaInterface/AssemblyInfo.cs | 56 ++ LuaInterface/CheckType.cs | 314 +++++++++ LuaInterface/GenerateEventAssembly.cs | 683 +++++++++++++++++++ LuaInterface/Lua.cs | 761 +++++++++++++++++++++ LuaInterface/LuaBase.cs | 56 ++ LuaInterface/LuaDLL.cs | 456 +++++++++++++ LuaInterface/LuaException.cs | 29 + LuaInterface/LuaFunction.cs | 115 ++++ LuaInterface/LuaGlobalAttribute.cs | 23 + LuaInterface/LuaHideAttribute.cs | 11 + LuaInterface/LuaInterface.csproj | 47 ++ LuaInterface/LuaRegistrationHelper.cs | 90 +++ LuaInterface/LuaScriptException.cs | 50 ++ LuaInterface/LuaTable.cs | 145 ++++ LuaInterface/LuaUserData.cs | 82 +++ LuaInterface/Metatables.cs | 935 ++++++++++++++++++++++++++ LuaInterface/MethodWrapper.cs | 595 ++++++++++++++++ LuaInterface/ObjectTranslator.cs | 870 ++++++++++++++++++++++++ LuaInterface/ProxyType.cs | 94 +++ OpenRA.sln | 10 + 21 files changed, 5425 insertions(+) create mode 100644 LuaInterface/AssemblyInfo.cs create mode 100644 LuaInterface/CheckType.cs create mode 100644 LuaInterface/GenerateEventAssembly.cs create mode 100644 LuaInterface/Lua.cs create mode 100644 LuaInterface/LuaBase.cs create mode 100644 LuaInterface/LuaDLL.cs create mode 100644 LuaInterface/LuaException.cs create mode 100644 LuaInterface/LuaFunction.cs create mode 100644 LuaInterface/LuaGlobalAttribute.cs create mode 100644 LuaInterface/LuaHideAttribute.cs create mode 100644 LuaInterface/LuaInterface.csproj create mode 100644 LuaInterface/LuaRegistrationHelper.cs create mode 100644 LuaInterface/LuaScriptException.cs create mode 100644 LuaInterface/LuaTable.cs create mode 100644 LuaInterface/LuaUserData.cs create mode 100644 LuaInterface/Metatables.cs create mode 100644 LuaInterface/MethodWrapper.cs create mode 100644 LuaInterface/ObjectTranslator.cs create mode 100644 LuaInterface/ProxyType.cs diff --git a/AUTHORS b/AUTHORS index 960bb57077..19d7cd2132 100644 --- a/AUTHORS +++ b/AUTHORS @@ -69,6 +69,9 @@ Also thanks to: Using GeoLite data created by MaxMind and distributed under the CC BY-SA 3.0 license. +Using MonoBoxedLua created by Sparklin Labs +and distributed under the MIT license. + Finally, special thanks goes to the original teams at Westwood Studios and EA for creating the classic games which OpenRA aims to reimagine. diff --git a/LuaInterface/AssemblyInfo.cs b/LuaInterface/AssemblyInfo.cs new file mode 100644 index 0000000000..70db5f2c9b --- /dev/null +++ b/LuaInterface/AssemblyInfo.cs @@ -0,0 +1,56 @@ +using System; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Security.Permissions; + +// +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +// +[assembly: AssemblyTitle("LuaInterface")] +[assembly: AssemblyDescription("Bridge between the Lua runtime and the CLR")] +[assembly: AssemblyCopyright("Copyright 2003-2008 Fabio Mascarenhas, Kevin Hester")] +[assembly: CLSCompliant(false)] + +// +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Revision and Build Numbers +// by using the '*' as shown below: + +[assembly: AssemblyVersion("2.0.4.*")] + +// +// In order to sign your assembly you must specify a key to use. Refer to the +// Microsoft .NET Framework documentation for more information on assembly signing. +// +// Use the attributes below to control which key is used for signing. +// +// Notes: +// (*) If no key is specified, the assembly is not signed. +// (*) KeyName refers to a key that has been installed in the Crypto Service +// Provider (CSP) on your machine. KeyFile refers to a file which contains +// a key. +// (*) If the KeyFile and the KeyName values are both specified, the +// following processing occurs: +// (1) If the KeyName can be found in the CSP, that key is used. +// (2) If the KeyName does not exist and the KeyFile does exist, the key +// in the KeyFile is installed into the CSP and used. +// (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility. +// When specifying the KeyFile, the location of the KeyFile should be +// relative to the project output directory which is +// %Project Directory%\obj\. For example, if your KeyFile is +// located in the project directory, you would specify the AssemblyKeyFile +// attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")] +// (*) Delay Signing is an advanced option - see the Microsoft .NET Framework +// documentation for more information on this. +// + +// We call native DLLs (lua50) and we don't want to be fucked with or validated +// [assembly: SecurityPermission(RequestMinimum, UnmanagedCode = true)] diff --git a/LuaInterface/CheckType.cs b/LuaInterface/CheckType.cs new file mode 100644 index 0000000000..6fda337278 --- /dev/null +++ b/LuaInterface/CheckType.cs @@ -0,0 +1,314 @@ +using System; +using System.Collections.Generic; +using System.Reflection; + +namespace LuaInterface +{ + /* + * Type checking and conversion functions. + * + * Author: Fabio Mascarenhas + * Version: 1.0 + */ + class CheckType + { + private ObjectTranslator translator; + + ExtractValue extractNetObject; + Dictionary extractValues = new Dictionary(); + + public CheckType(ObjectTranslator translator) + { + this.translator = translator; + + extractValues.Add(typeof(object).TypeHandle.Value.ToInt64(), new ExtractValue(getAsObject)); + extractValues.Add(typeof(sbyte).TypeHandle.Value.ToInt64(), new ExtractValue(getAsSbyte)); + extractValues.Add(typeof(byte).TypeHandle.Value.ToInt64(), new ExtractValue(getAsByte)); + extractValues.Add(typeof(short).TypeHandle.Value.ToInt64(), new ExtractValue(getAsShort)); + extractValues.Add(typeof(ushort).TypeHandle.Value.ToInt64(), new ExtractValue(getAsUshort)); + extractValues.Add(typeof(int).TypeHandle.Value.ToInt64(), new ExtractValue(getAsInt)); + extractValues.Add(typeof(uint).TypeHandle.Value.ToInt64(), new ExtractValue(getAsUint)); + extractValues.Add(typeof(long).TypeHandle.Value.ToInt64(), new ExtractValue(getAsLong)); + extractValues.Add(typeof(ulong).TypeHandle.Value.ToInt64(), new ExtractValue(getAsUlong)); + extractValues.Add(typeof(double).TypeHandle.Value.ToInt64(), new ExtractValue(getAsDouble)); + extractValues.Add(typeof(char).TypeHandle.Value.ToInt64(), new ExtractValue(getAsChar)); + extractValues.Add(typeof(float).TypeHandle.Value.ToInt64(), new ExtractValue(getAsFloat)); + extractValues.Add(typeof(decimal).TypeHandle.Value.ToInt64(), new ExtractValue(getAsDecimal)); + extractValues.Add(typeof(bool).TypeHandle.Value.ToInt64(), new ExtractValue(getAsBoolean)); + extractValues.Add(typeof(string).TypeHandle.Value.ToInt64(), new ExtractValue(getAsString)); + extractValues.Add(typeof(LuaFunction).TypeHandle.Value.ToInt64(), new ExtractValue(getAsFunction)); + extractValues.Add(typeof(LuaTable).TypeHandle.Value.ToInt64(), new ExtractValue(getAsTable)); + extractValues.Add(typeof(LuaUserData).TypeHandle.Value.ToInt64(), new ExtractValue(getAsUserdata)); + + extractNetObject = new ExtractValue(getAsNetObject); + } + + /* + * Checks if the value at Lua stack index stackPos matches paramType, + * returning a conversion function if it does and null otherwise. + */ + internal ExtractValue getExtractor(IReflect paramType) + { + return getExtractor(paramType.UnderlyingSystemType); + } + internal ExtractValue getExtractor(Type paramType) + { + if(paramType.IsByRef) paramType=paramType.GetElementType(); + + long runtimeHandleValue = paramType.TypeHandle.Value.ToInt64(); + + if(extractValues.ContainsKey(runtimeHandleValue)) + return extractValues[runtimeHandleValue]; + else + return extractNetObject; + } + + internal ExtractValue checkType(IntPtr luaState,int stackPos,Type paramType) + { + LuaTypes luatype = LuaDLL.lua_type(luaState, stackPos); + + if(paramType.IsByRef) paramType=paramType.GetElementType(); + + Type underlyingType = Nullable.GetUnderlyingType(paramType); + if (underlyingType != null) + { + paramType = underlyingType; // Silently convert nullable types to their non null requics + } + + long runtimeHandleValue = paramType.TypeHandle.Value.ToInt64(); + + if (paramType.Equals(typeof(object))) + return extractValues[runtimeHandleValue]; + + /* + //CP: Added support for generic parameters + if (paramType.IsGenericParameter) + { + if (luatype == LuaTypes.LUA_TBOOLEAN) + return extractValues[typeof(bool).TypeHandle.Value.ToInt64()]; + else if (luatype == LuaTypes.LUA_TSTRING) + return extractValues[typeof(string).TypeHandle.Value.ToInt64()]; + else if (luatype == LuaTypes.LUA_TTABLE) + return extractValues[typeof(LuaTable).TypeHandle.Value.ToInt64()]; + else if (luatype == LuaTypes.LUA_TUSERDATA) + return extractValues[typeof(object).TypeHandle.Value.ToInt64()]; + else if (luatype == LuaTypes.LUA_TFUNCTION) + return extractValues[typeof(LuaFunction).TypeHandle.Value.ToInt64()]; + else if (luatype == LuaTypes.LUA_TNUMBER) + return extractValues[typeof(double).TypeHandle.Value.ToInt64()]; + //else // suppress CS0642 + ;//an unsupported type was encountered + } + */ + + if (LuaDLL.lua_isnumber(luaState, stackPos)) + return extractValues[runtimeHandleValue]; + + if (paramType == typeof(bool)) + { + if (LuaDLL.lua_isboolean(luaState, stackPos)) + return extractValues[runtimeHandleValue]; + } + else if (paramType == typeof(string)) + { + if (LuaDLL.lua_isstring(luaState, stackPos)) + return extractValues[runtimeHandleValue]; + else if (luatype == LuaTypes.LUA_TNIL) + return extractNetObject; // kevinh - silently convert nil to a null string pointer + } + else if (paramType == typeof(LuaTable)) + { + if (luatype == LuaTypes.LUA_TTABLE) + return extractValues[runtimeHandleValue]; + else if (luatype == LuaTypes.LUA_TNIL) + return extractNetObject; // tkopal - silently convert nil to a null table + } + else if (paramType == typeof(LuaUserData)) + { + if (luatype == LuaTypes.LUA_TUSERDATA) + return extractValues[runtimeHandleValue]; + } + else if (paramType == typeof(LuaFunction)) + { + if (luatype == LuaTypes.LUA_TFUNCTION) + return extractValues[runtimeHandleValue]; + else if (luatype == LuaTypes.LUA_TNIL) + return extractNetObject; // elisee - silently convert nil to a null string pointer + } + else if (typeof(Delegate).IsAssignableFrom(paramType) && luatype == LuaTypes.LUA_TFUNCTION) + { + return new ExtractValue(new DelegateGenerator(translator, paramType).extractGenerated); + } + else if (paramType.IsInterface && luatype == LuaTypes.LUA_TTABLE) + { + return new ExtractValue(new ClassGenerator(translator, paramType).extractGenerated); + } + else if ((paramType.IsInterface || paramType.IsClass) && luatype == LuaTypes.LUA_TNIL) + { + // kevinh - allow nil to be silently converted to null - extractNetObject will return null when the item ain't found + return extractNetObject; + } + else if (LuaDLL.lua_type(luaState, stackPos) == LuaTypes.LUA_TTABLE) + { + if (LuaDLL.luaL_getmetafield(luaState, stackPos, "__index")) + { + object obj = translator.getNetObject(luaState, -1); + LuaDLL.lua_settop(luaState, -2); + if (obj != null && paramType.IsAssignableFrom(obj.GetType())) + return extractNetObject; + } + else + return null; + } + else + { + object obj = translator.getNetObject(luaState, stackPos); + if (obj != null && paramType.IsAssignableFrom(obj.GetType())) + return extractNetObject; + } + + return null; + } + + /* + * The following functions return the value in the Lua stack + * index stackPos as the desired type if it can, or null + * otherwise. + */ + private object getAsSbyte(IntPtr luaState,int stackPos) + { + sbyte retVal=(sbyte)LuaDLL.lua_tonumber(luaState,stackPos); + if(retVal==0 && !LuaDLL.lua_isnumber(luaState,stackPos)) return null; + return retVal; + } + private object getAsByte(IntPtr luaState,int stackPos) + { + byte retVal=(byte)LuaDLL.lua_tonumber(luaState,stackPos); + if(retVal==0 && !LuaDLL.lua_isnumber(luaState,stackPos)) return null; + return retVal; + } + private object getAsShort(IntPtr luaState,int stackPos) + { + short retVal=(short)LuaDLL.lua_tonumber(luaState,stackPos); + if(retVal==0 && !LuaDLL.lua_isnumber(luaState,stackPos)) return null; + return retVal; + } + private object getAsUshort(IntPtr luaState,int stackPos) + { + ushort retVal=(ushort)LuaDLL.lua_tonumber(luaState,stackPos); + if(retVal==0 && !LuaDLL.lua_isnumber(luaState,stackPos)) return null; + return retVal; + } + private object getAsInt(IntPtr luaState,int stackPos) + { + int retVal=(int)LuaDLL.lua_tonumber(luaState,stackPos); + if(retVal==0 && !LuaDLL.lua_isnumber(luaState,stackPos)) return null; + return retVal; + } + private object getAsUint(IntPtr luaState,int stackPos) + { + uint retVal=(uint)LuaDLL.lua_tonumber(luaState,stackPos); + if(retVal==0 && !LuaDLL.lua_isnumber(luaState,stackPos)) return null; + return retVal; + } + private object getAsLong(IntPtr luaState,int stackPos) + { + long retVal=(long)LuaDLL.lua_tonumber(luaState,stackPos); + if(retVal==0 && !LuaDLL.lua_isnumber(luaState,stackPos)) return null; + return retVal; + } + private object getAsUlong(IntPtr luaState,int stackPos) + { + ulong retVal=(ulong)LuaDLL.lua_tonumber(luaState,stackPos); + if(retVal==0 && !LuaDLL.lua_isnumber(luaState,stackPos)) return null; + return retVal; + } + private object getAsDouble(IntPtr luaState,int stackPos) + { + double retVal=LuaDLL.lua_tonumber(luaState,stackPos); + if(retVal==0 && !LuaDLL.lua_isnumber(luaState,stackPos)) return null; + return retVal; + } + private object getAsChar(IntPtr luaState,int stackPos) + { + char retVal=(char)LuaDLL.lua_tonumber(luaState,stackPos); + if(retVal==0 && !LuaDLL.lua_isnumber(luaState,stackPos)) return null; + return retVal; + } + private object getAsFloat(IntPtr luaState,int stackPos) + { + float retVal=(float)LuaDLL.lua_tonumber(luaState,stackPos); + if(retVal==0 && !LuaDLL.lua_isnumber(luaState,stackPos)) return null; + return retVal; + } + private object getAsDecimal(IntPtr luaState,int stackPos) + { + decimal retVal=(decimal)LuaDLL.lua_tonumber(luaState,stackPos); + if(retVal==0 && !LuaDLL.lua_isnumber(luaState,stackPos)) return null; + return retVal; + } + private object getAsBoolean(IntPtr luaState,int stackPos) + { + return LuaDLL.lua_toboolean(luaState,stackPos); + } + private object getAsString(IntPtr luaState,int stackPos) + { + string retVal=LuaDLL.lua_tostring(luaState,stackPos); + if(retVal=="" && !LuaDLL.lua_isstring(luaState,stackPos)) return null; + return retVal; + } + private object getAsTable(IntPtr luaState,int stackPos) + { + return translator.getTable(luaState,stackPos); + } + private object getAsFunction(IntPtr luaState,int stackPos) + { + return translator.getFunction(luaState,stackPos); + } + private object getAsUserdata(IntPtr luaState,int stackPos) + { + return translator.getUserData(luaState,stackPos); + } + public object getAsObject(IntPtr luaState,int stackPos) + { + if(LuaDLL.lua_type(luaState,stackPos)==LuaTypes.LUA_TTABLE) + { + if(LuaDLL.luaL_getmetafield(luaState,stackPos,"__index")) + { + if(LuaDLL.luaL_checkmetatable(luaState,-1)) + { + LuaDLL.lua_insert(luaState,stackPos); + LuaDLL.lua_remove(luaState,stackPos+1); + } + else + { + LuaDLL.lua_settop(luaState,-2); + } + } + } + object obj=translator.getObject(luaState,stackPos); + return obj; + } + public object getAsNetObject(IntPtr luaState,int stackPos) + { + object obj=translator.getNetObject(luaState,stackPos); + if(obj==null && LuaDLL.lua_type(luaState,stackPos)==LuaTypes.LUA_TTABLE) + { + if(LuaDLL.luaL_getmetafield(luaState,stackPos,"__index")) + { + if(LuaDLL.luaL_checkmetatable(luaState,-1)) + { + LuaDLL.lua_insert(luaState,stackPos); + LuaDLL.lua_remove(luaState,stackPos+1); + obj=translator.getNetObject(luaState,stackPos); + } + else + { + LuaDLL.lua_settop(luaState,-2); + } + } + } + return obj; + } + } +} diff --git a/LuaInterface/GenerateEventAssembly.cs b/LuaInterface/GenerateEventAssembly.cs new file mode 100644 index 0000000000..775b62a2cb --- /dev/null +++ b/LuaInterface/GenerateEventAssembly.cs @@ -0,0 +1,683 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Reflection; +using System.Reflection.Emit; +using System.Threading; + +namespace LuaInterface +{ + /* + * Structure to store a type and the return types of + * its methods (the type of the returned value and out/ref + * parameters). + */ + struct LuaClassType + { + public Type klass; + public Type[][] returnTypes; + } + + /* + * Common interface for types generated from tables. The method + * returns the table that overrides some or all of the type's methods. + */ + public interface ILuaGeneratedType + { + LuaTable __luaInterface_getLuaTable(); + } + + /* + * Class used for generating delegates that get a function from the Lua + * stack as a delegate of a specific type. + * + * Author: Fabio Mascarenhas + * Version: 1.0 + */ + class DelegateGenerator + { + private ObjectTranslator translator; + private Type delegateType; + + public DelegateGenerator(ObjectTranslator translator,Type delegateType) + { + this.translator=translator; + this.delegateType=delegateType; + } + public object extractGenerated(IntPtr luaState,int stackPos) + { + return CodeGeneration.Instance.GetDelegate(delegateType,translator.getFunction(luaState,stackPos)); + } + } + + /* + * Class used for generating delegates that get a table from the Lua + * stack as a an object of a specific type. + * + * Author: Fabio Mascarenhas + * Version: 1.0 + */ + class ClassGenerator + { + private ObjectTranslator translator; + private Type klass; + + public ClassGenerator(ObjectTranslator translator,Type klass) + { + this.translator=translator; + this.klass=klass; + } + public object extractGenerated(IntPtr luaState,int stackPos) + { + return CodeGeneration.Instance.GetClassInstance(klass,translator.getTable(luaState,stackPos)); + } + } + + /* + * Dynamically generates new types from existing types and + * Lua function and table values. Generated types are event handlers, + * delegates, interface implementations and subclasses. + * + * Author: Fabio Mascarenhas + * Version: 1.0 + */ + class CodeGeneration + { + private Type eventHandlerParent=typeof(LuaEventHandler); + private Dictionary eventHandlerCollection=new Dictionary(); + + private Type delegateParent=typeof(LuaDelegate); + private Dictionary delegateCollection=new Dictionary(); + + private Type classHelper=typeof(LuaClassHelper); + private Dictionary classCollection=new Dictionary(); + + private AssemblyName assemblyName; + private AssemblyBuilder newAssembly; + private ModuleBuilder newModule; + private int luaClassNumber=1; + private static readonly CodeGeneration instance = new CodeGeneration(); + + static CodeGeneration() + { + } + + private CodeGeneration() + { + // Create an assembly name + assemblyName=new AssemblyName( ); + assemblyName.Name="LuaInterface_generatedcode"; + // Create a new assembly with one module. + newAssembly=Thread.GetDomain().DefineDynamicAssembly( + assemblyName, AssemblyBuilderAccess.Run); + newModule=newAssembly.DefineDynamicModule("LuaInterface_generatedcode"); + } + + /* + * Singleton instance of the class + */ + public static CodeGeneration Instance + { + get + { + return instance; + } + } + + /* + * Generates an event handler that calls a Lua function + */ + private Type GenerateEvent(Type eventHandlerType) + { + string typeName; + lock(this) + { + typeName = "LuaGeneratedClass" + luaClassNumber; + luaClassNumber++; + } + // Define a public class in the assembly, called typeName + TypeBuilder myType=newModule.DefineType(typeName,TypeAttributes.Public,eventHandlerParent); + + // Defines the handler method. Its signature is void(object,) + Type[] paramTypes = new Type[2]; + paramTypes[0]=typeof(object); + paramTypes[1]=eventHandlerType; + Type returnType=typeof(void); + MethodBuilder handleMethod=myType.DefineMethod("HandleEvent", + MethodAttributes.Public|MethodAttributes.HideBySig, + returnType,paramTypes); + + // Emits the IL for the method. It loads the arguments + // and calls the handleEvent method of the base class + ILGenerator generator=handleMethod.GetILGenerator( ); + generator.Emit(OpCodes.Ldarg_0); + generator.Emit(OpCodes.Ldarg_1); + generator.Emit(OpCodes.Ldarg_2); + MethodInfo miGenericEventHandler; + miGenericEventHandler=eventHandlerParent.GetMethod("handleEvent"); + generator.Emit(OpCodes.Call,miGenericEventHandler); + // returns + generator.Emit(OpCodes.Ret); + + // creates the new type + return myType.CreateType(); + } + + /* + * Generates a type that can be used for instantiating a delegate + * of the provided type, given a Lua function. + */ + private Type GenerateDelegate(Type delegateType) + { + string typeName; + lock(this) + { + typeName = "LuaGeneratedClass" + luaClassNumber; + luaClassNumber++; + } + // Define a public class in the assembly, called typeName + TypeBuilder myType=newModule.DefineType(typeName,TypeAttributes.Public,delegateParent); + + // Defines the delegate method with the same signature as the + // Invoke method of delegateType + MethodInfo invokeMethod=delegateType.GetMethod("Invoke"); + ParameterInfo[] paramInfo=invokeMethod.GetParameters(); + Type[] paramTypes=new Type[paramInfo.Length]; + Type returnType=invokeMethod.ReturnType; + + // Counts out and ref params, for use later + int nOutParams=0; int nOutAndRefParams=0; + for(int i=0;i returnTypesList=new List(); + + // Counts out and ref parameters, for later use, + // and creates the list of return types + int nOutParams=0; int nOutAndRefParams=0; + Type returnType=method.ReturnType; + returnTypesList.Add(returnType); + for(int i=0;i returnTypes=new List(); + Type luaDelegateType; + if (delegateCollection.ContainsKey(delegateType)) + { + luaDelegateType=delegateCollection[delegateType]; + } + else + { + luaDelegateType=GenerateDelegate(delegateType); + delegateCollection[delegateType] = luaDelegateType; + } + MethodInfo methodInfo=delegateType.GetMethod("Invoke"); + returnTypes.Add(methodInfo.ReturnType); + foreach(ParameterInfo paramInfo in methodInfo.GetParameters()) + if(paramInfo.ParameterType.IsByRef) + returnTypes.Add(paramInfo.ParameterType); + LuaDelegate luaDelegate=(LuaDelegate)Activator.CreateInstance(luaDelegateType); + luaDelegate.function=luaFunc; + luaDelegate.returnTypes=returnTypes.ToArray(); + return Delegate.CreateDelegate(delegateType,luaDelegate,"CallFunction"); + } + + /* + * Gets an instance of an implementation of the klass interface or + * subclass of klass that delegates public virtual methods to the + * luaTable table. + * Caches the generated type. + */ + public object GetClassInstance(Type klass, LuaTable luaTable) + { + LuaClassType luaClassType; + if (classCollection.ContainsKey(klass)) + { + luaClassType=classCollection[klass]; + } + else + { + luaClassType=new LuaClassType(); + GenerateClass(klass,out luaClassType.klass,out luaClassType.returnTypes,luaTable); + classCollection[klass] = luaClassType; + } + return Activator.CreateInstance(luaClassType.klass,new object[] {luaTable,luaClassType.returnTypes}); + } + } +} diff --git a/LuaInterface/Lua.cs b/LuaInterface/Lua.cs new file mode 100644 index 0000000000..cc5ba42077 --- /dev/null +++ b/LuaInterface/Lua.cs @@ -0,0 +1,761 @@ + +namespace LuaInterface +{ + using System; + using System.IO; + using System.Collections; + using System.Collections.Generic; + using System.Collections.Specialized; + using System.Reflection; + using System.Threading; + using OpenRA; + using System.Text; + + /* + * Main class of LuaInterface + * Object-oriented wrapper to Lua API + * + * Author: Fabio Mascarenhas + * Version: 1.0 + * + * // steffenj: important changes in Lua class: + * - removed all Open*Lib() functions + * - all libs automatically open in the Lua class constructor (just assign nil to unwanted libs) + * */ + public class Lua : IDisposable + { + /*readonly */ IntPtr luaState; + ObjectTranslator translator; + + LuaFunctionCallback panicCallback; + LuaCSFunction tracebackFunction; + // lockCallback, unlockCallback; used by debug code commented out for now + + public Lua() + { + luaState = LuaDLL.luaL_newstate(); // steffenj: Lua 5.1.1 API change (lua_open is gone) + + // Load libraries + LuaDLL.luaL_openlibs(luaState); + + // Add LuaInterface marker + LuaDLL.lua_pushstring(luaState, "LUAINTERFACE LOADED"); + LuaDLL.lua_pushboolean(luaState, true); + LuaDLL.lua_settable(luaState, (int) LuaIndexes.LUA_REGISTRYINDEX); + + translator=new ObjectTranslator(this,luaState); + + tracebackFunction = new LuaCSFunction(traceback); + + // We need to keep this in a managed reference so the delegate doesn't get garbage collected + panicCallback = new LuaFunctionCallback(PanicCallback); + LuaDLL.lua_atpanic(luaState, panicCallback); + } + + private bool _StatePassed; + + /* + * CAUTION: LuaInterface.Lua instances can't share the same lua state! + */ + public Lua( Int64 luaState ) + { + // Check for existing LuaInterface marker + IntPtr lState = new IntPtr(luaState); + LuaDLL.lua_pushstring(lState, "LUAINTERFACE LOADED"); + LuaDLL.lua_gettable(lState, (int)LuaIndexes.LUA_REGISTRYINDEX); + + if(LuaDLL.lua_toboolean(lState,-1)) + { + LuaDLL.lua_settop(lState,-2); + throw new LuaException("There is already a LuaInterface.Lua instance associated with this Lua state"); + } + else + { + // Add LuaInterface marker + LuaDLL.lua_settop(lState,-2); + LuaDLL.lua_pushstring(lState, "LUAINTERFACE LOADED"); + LuaDLL.lua_pushboolean(lState, true); + LuaDLL.lua_settable(lState, (int)LuaIndexes.LUA_REGISTRYINDEX); + + this.luaState = lState; + LuaDLL.lua_pushvalue(lState, (int)LuaIndexes.LUA_GLOBALSINDEX); + + translator = new ObjectTranslator(this, this.luaState); + } + + _StatePassed = true; + } + + public void Close() + { + if (_StatePassed) + return; + + if (luaState != IntPtr.Zero) + LuaDLL.lua_close(luaState); + //luaState = IntPtr.Zero; <- suggested by Christopher Cebulski http://luaforge.net/forum/forum.php?thread_id=44593&forum_id=146 + } + + static int PanicCallback(IntPtr luaState) + { + // string desc = LuaDLL.lua_tostring(luaState, 1); + string reason = String.Format("unprotected error in call to Lua API ({0})", LuaDLL.lua_tostring(luaState, -1)); + + // lua_tostring(L, -1); + + throw new LuaException(reason); + } + + + + /// + /// Assuming we have a Lua error string sitting on the stack, throw a C# exception out to the user's app + /// + /// Thrown if the script caused an exception + void ThrowExceptionFromError(int oldTop) + { + object err = translator.getObject(luaState, -1); + LuaDLL.lua_settop(luaState, oldTop); + + // A pre-wrapped exception - just rethrow it (stack trace of InnerException will be preserved) + LuaScriptException luaEx = err as LuaScriptException; + if (luaEx != null) throw luaEx; + + // A non-wrapped Lua error (best interpreted as a string) - wrap it and throw it + if (err == null) err = "Unknown Lua Error"; + throw new LuaScriptException(err.ToString(), ""); + } + + + + /// + /// Convert C# exceptions into Lua errors + /// + /// num of things on stack + /// null for no pending exception + internal int SetPendingException(Exception e) + { + Exception caughtExcept = e; + + if (caughtExcept != null) + { + translator.throwError(luaState, caughtExcept); + LuaDLL.lua_pushnil(luaState); + + return 1; + } + else + return 0; + } + + private bool executing; + + /// + /// True while a script is being executed + /// + public bool IsExecuting { get { return executing; } } + + /// + /// + /// + /// + /// + /// + public LuaFunction LoadString(string chunk, string name) + { + int oldTop = LuaDLL.lua_gettop(luaState); + + executing = true; + + // Somehow, on OS X, we need to use the UTF-8 byte count rather than the string length + // Adapted for OpenRA + var chunkLength = Platform.CurrentPlatform != PlatformType.Windows + ? Encoding.UTF8.GetByteCount(chunk) + : chunk.Length; + + try + { + if (LuaDLL.luaL_loadbuffer(luaState, chunk, chunkLength, name) != 0) + ThrowExceptionFromError(oldTop); + } + finally { executing = false; } + + LuaFunction result = translator.getFunction(luaState, -1); + translator.popValues(luaState, oldTop); + + return result; + } + + /// + /// + /// + /// + /// + public LuaFunction LoadFile(string fileName) + { + int oldTop = LuaDLL.lua_gettop(luaState); + if (LuaDLL.luaL_loadfile(luaState, fileName) != 0) + ThrowExceptionFromError(oldTop); + + LuaFunction result = translator.getFunction(luaState, -1); + translator.popValues(luaState, oldTop); + + return result; + } + + + /* + * Excutes a Lua chunk and returns all the chunk's return + * values in an array + */ + public object[] DoString(string chunk) + { + return DoString(chunk,"chunk"); + } + + /// + /// Executes a Lua chnk and returns all the chunk's return values in an array. + /// + /// Chunk to execute + /// Name to associate with the chunk + /// + public object[] DoString(string chunk, string chunkName) + { + int oldTop = LuaDLL.lua_gettop(luaState); + executing = true; + + // Somehow, on OS X, we need to use the UTF-8 byte count rather than the string length + // Adapted for OpenRA + var chunkLength = Platform.CurrentPlatform != PlatformType.Windows + ? Encoding.UTF8.GetByteCount(chunk) + : chunk.Length; + + if (LuaDLL.luaL_loadbuffer(luaState, chunk, chunkLength, chunkName) == 0) + { + try + { + if (LuaDLL.lua_pcall(luaState, 0, -1, 0) == 0) + return translator.popValues(luaState, oldTop); + else + ThrowExceptionFromError(oldTop); + } + finally { executing = false; } + } + else + ThrowExceptionFromError(oldTop); + + return null; // Never reached - keeps compiler happy + } + + private int traceback(IntPtr luaState) + { + LuaDLL.lua_getglobal(luaState,"debug"); + LuaDLL.lua_getfield(luaState,-1,"traceback"); + LuaDLL.lua_pushvalue(luaState,1); + LuaDLL.lua_pushnumber(luaState,2); + LuaDLL.lua_call (luaState,2,1); + return 1; + } + + /* + * Excutes a Lua file and returns all the chunk's return + * values in an array + */ + public object[] DoFile(string fileName) + { + LuaDLL.lua_pushstdcallcfunction(luaState,tracebackFunction); + int oldTop=LuaDLL.lua_gettop(luaState); + if(LuaDLL.luaL_loadfile(luaState,fileName)==0) + { + executing = true; + try + { + if (LuaDLL.lua_pcall(luaState, 0, -1, -2) == 0) + return translator.popValues(luaState, oldTop); + else + ThrowExceptionFromError(oldTop); + } + finally { executing = false; } + } + else + ThrowExceptionFromError(oldTop); + + return null; // Never reached - keeps compiler happy + } + + + public void CollectGarbage() + { + LuaDLL.lua_gc( luaState, LuaGCOptions.LUA_GCCOLLECT, 0 ); + } + + /* + * Indexer for global variables from the LuaInterpreter + * Supports navigation of tables by using . operator + */ + public object this[string fullPath] + { + get + { + object returnValue=null; + int oldTop=LuaDLL.lua_gettop(luaState); + string[] path=fullPath.Split(new char[] { '.' }); + LuaDLL.lua_getglobal(luaState,path[0]); + returnValue=translator.getObject(luaState,-1); + if(path.Length>1) + { + string[] remainingPath=new string[path.Length-1]; + Array.Copy(path,1,remainingPath,0,path.Length-1); + returnValue=getObject(remainingPath); + } + LuaDLL.lua_settop(luaState,oldTop); + return returnValue; + } + set + { + int oldTop=LuaDLL.lua_gettop(luaState); + string[] path=fullPath.Split(new char[] { '.' }); + if(path.Length==1) + { + translator.push(luaState,value); + LuaDLL.lua_setglobal(luaState,fullPath); + } + else + { + LuaDLL.lua_getglobal(luaState,path[0]); + string[] remainingPath=new string[path.Length-1]; + Array.Copy(path,1,remainingPath,0,path.Length-1); + setObject(remainingPath,value); + } + LuaDLL.lua_settop(luaState,oldTop); + + // Globals auto-complete + if (value == null) + { + // Remove now obsolete entries + globals.Remove(fullPath); + } + else + { + // Add new entries + if (!globals.Contains(fullPath)) + registerGlobal(fullPath, value.GetType(), 0); + } + } + } + + #region Globals auto-complete + private readonly List globals = new List(); + private bool globalsSorted; + + /// + /// An alphabetically sorted list of all globals (objects, methods, etc.) externally added to this Lua instance + /// + /// Members of globals are also listed. The formatting is optimized for text input auto-completion. + public IEnumerable Globals + { + get + { + // Only sort list when necessary + if (!globalsSorted) + { + globals.Sort(); + globalsSorted = true; + } + + return globals; + } + } + + /// + /// Adds an entry to (recursivley handles 2 levels of members) + /// + /// The index accessor path ot the entry + /// The type of the entry + /// How deep have we gone with recursion? + private void registerGlobal(string path, Type type, int recursionCounter) + { + // If the type is a global method, list it directly + if (type == typeof(LuaCSFunction)) + { + // Format for easy method invocation + globals.Add(path + "("); + } + // If the type is a class or an interface and recursion hasn't been running too long, list the members + else if ((type.IsClass || type.IsInterface) && type != typeof(string) && recursionCounter < 2) + { + #region Methods + foreach (MethodInfo method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance)) + { + if ( + // Check that the LuaHideAttribute and LuaGlobalAttribute were not applied + (method.GetCustomAttributes(typeof(LuaHideAttribute), false).Length == 0) && + (method.GetCustomAttributes(typeof(LuaGlobalAttribute), false).Length == 0) && + // Exclude some generic .NET methods that wouldn't be very usefull in Lua + method.Name != "GetType" && method.Name != "GetHashCode" && method.Name != "Equals" && + method.Name != "ToString" && method.Name != "Clone" && method.Name != "Dispose" && + method.Name != "GetEnumerator" && method.Name != "CopyTo" && + !method.Name.StartsWith("get_", StringComparison.Ordinal) && + !method.Name.StartsWith("set_", StringComparison.Ordinal) && + !method.Name.StartsWith("add_", StringComparison.Ordinal) && + !method.Name.StartsWith("remove_", StringComparison.Ordinal)) + { + // Format for easy method invocation + string command = path + ":" + method.Name + "("; + if (method.GetParameters().Length == 0) command += ")"; + globals.Add(command); + } + } + #endregion + + #region Fields + foreach (FieldInfo field in type.GetFields(BindingFlags.Public | BindingFlags.Instance)) + { + if ( + // Check that the LuaHideAttribute and LuaGlobalAttribute were not applied + (field.GetCustomAttributes(typeof(LuaHideAttribute), false).Length == 0) && + (field.GetCustomAttributes(typeof(LuaGlobalAttribute), false).Length == 0)) + { + // Go into recursion for members + registerGlobal(path + "." + field.Name, field.FieldType, recursionCounter + 1); + } + } + #endregion + + #region Properties + foreach (PropertyInfo property in type.GetProperties(BindingFlags.Public | BindingFlags.Instance)) + { + if ( + // Check that the LuaHideAttribute and LuaGlobalAttribute were not applied + (property.GetCustomAttributes(typeof(LuaHideAttribute), false).Length == 0) && + (property.GetCustomAttributes(typeof(LuaGlobalAttribute), false).Length == 0) + // Exclude some generic .NET properties that wouldn't be very usefull in Lua + && property.Name != "Item") + { + // Go into recursion for members + registerGlobal(path + "." + property.Name, property.PropertyType, recursionCounter + 1); + } + } + #endregion + } + // Otherwise simply add the element to the list + else globals.Add(path); + + // List will need to be sorted on next access + globalsSorted = false; + } + #endregion + + /* + * Navigates a table in the top of the stack, returning + * the value of the specified field + */ + internal object getObject(string[] remainingPath) + { + object returnValue=null; + for(int i=0;i + /// Base class to provide consistent disposal flow across lua objects. Uses code provided by Yves Duhoux and suggestions by Hans Schmeidenbacher and Qingrui Li + /// + public abstract class LuaBase : IDisposable + { + private bool _Disposed; + protected int _Reference; + protected Lua _Interpreter; + + ~LuaBase() + { + Dispose(false); + } + + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + public virtual void Dispose(bool disposeManagedResources) + { + if (!_Disposed) + { + if (disposeManagedResources) + { + if (_Reference != 0) + _Interpreter.dispose(_Reference); + } + _Interpreter = null; + _Disposed = true; + } + } + + public override bool Equals(object o) + { + if (o is LuaBase) + { + LuaBase l = (LuaBase)o; + return _Interpreter.compareRef(l._Reference, _Reference); + } + else return false; + } + + public override int GetHashCode() + { + return _Reference; + } + } +} diff --git a/LuaInterface/LuaDLL.cs b/LuaInterface/LuaDLL.cs new file mode 100644 index 0000000000..3156a67dc9 --- /dev/null +++ b/LuaInterface/LuaDLL.cs @@ -0,0 +1,456 @@ +namespace LuaInterface +{ + + using System; + using System.Runtime.InteropServices; + using System.Reflection; + using System.Collections; + using System.Text; + using System.Security; + + /* + * Lua types for the API, returned by lua_type function + */ + public enum LuaTypes + { + LUA_TNONE=-1, + LUA_TNIL=0, + LUA_TNUMBER=3, + LUA_TSTRING=4, + LUA_TBOOLEAN=1, + LUA_TTABLE=5, + LUA_TFUNCTION=6, + LUA_TUSERDATA=7, + LUA_TLIGHTUSERDATA=2 + } + + // steffenj: BEGIN lua garbage collector options + /* + * Lua Garbage Collector options (param "what") + */ + public enum LuaGCOptions + { + LUA_GCSTOP = 0, + LUA_GCRESTART = 1, + LUA_GCCOLLECT = 2, + LUA_GCCOUNT = 3, + LUA_GCCOUNTB = 4, + LUA_GCSTEP = 5, + LUA_GCSETPAUSE = 6, + LUA_GCSETSTEPMUL = 7, + } + /* + sealed class LuaGCOptions + { + public static int LUA_GCSTOP = 0; + public static int LUA_GCRESTART = 1; + public static int LUA_GCCOLLECT = 2; + public static int LUA_GCCOUNT = 3; + public static int LUA_GCCOUNTB = 4; + public static int LUA_GCSTEP = 5; + public static int LUA_GCSETPAUSE = 6; + public static int LUA_GCSETSTEPMUL = 7; + }; + */ + // steffenj: END lua garbage collector options + + /* + * Special stack indexes + */ + sealed class LuaIndexes + { + public static int LUA_REGISTRYINDEX=-10000; + public static int LUA_ENVIRONINDEX=-10001; // steffenj: added environindex + public static int LUA_GLOBALSINDEX=-10002; // steffenj: globalsindex previously was -10001 + } + + /* + * Structure used by the chunk reader + */ + [ StructLayout( LayoutKind.Sequential )] + public struct ReaderInfo + { + public String chunkData; + public bool finished; + } + + /* + * Delegate for functions passed to Lua as function pointers + */ + public delegate int LuaCSFunction(IntPtr luaState); + + /* + * Delegate for chunk readers used with lua_load + */ + public delegate string LuaChunkReader(IntPtr luaState,ref ReaderInfo data,ref uint size); + + + /// + /// Used to handle Lua panics + /// + /// + /// + public delegate int LuaFunctionCallback(IntPtr luaState); + + /* + * P/Invoke wrapper of the Lua API + * + * Author: Fabio Mascarenhas + * Version: 1.0 + * + * // steffenj: noteable changes in the LuaDLL API: + * - luaopen_* functions are gone + * (however Lua class constructor already calls luaL_openlibs now, so just remove these calls) + * - deprecated functions: lua_open, lua_strlen, lua_dostring + * (they still work but may be removed with next Lua version) + * + * list of functions of the Lua 5.1.1 C API that are not in LuaDLL + * i thought this may come in handy for the next Lua version upgrade and for anyone to see + * what the differences are in the APIs (C API vs LuaDLL API) + lua_concat (use System.String concatenation or similar) + lua_cpcall (no point in calling C functions) + lua_dump (would write to unmanaged memory via lua_Writer) + lua_getallocf (no C functions/pointers) + lua_isthread (no threads) + lua_newstate (use luaL_newstate) + lua_newthread (no threads) + lua_pushcclosure (no C functions/pointers) + lua_pushcfunction (no C functions/pointers) + lua_pushfstring (use lua_pushstring) + lua_pushthread (no threads) + lua_pushvfstring (use lua_pushstring) + lua_register (all libs already opened, use require in scripts for external libs) + lua_resume (no threads) + lua_setallocf (no C functions/pointers) + lua_status (no threads) + lua_tointeger (use System.Convert) + lua_tolstring (use lua_tostring) + lua_topointer (no C functions/pointers) + lua_tothread (no threads) + lua_xmove (no threads) + lua_yield (no threads) + + luaL_add* (use System.String concatenation or similar) + luaL_argcheck (function argument checking unnecessary) + luaL_argerror (function argument checking unnecessary) + luaL_buffinit (use System.String concatenation or similar) + luaL_checkany (function argument checking unnecessary) + luaL_checkint (function argument checking unnecessary) + luaL_checkinteger (function argument checking unnecessary) + luaL_checklong (function argument checking unnecessary) + luaL_checklstring (function argument checking unnecessary) + luaL_checknumber (function argument checking unnecessary) + luaL_checkoption (function argument checking unnecessary) + luaL_checkstring (function argument checking unnecessary) + luaL_checktype (function argument checking unnecessary) + luaL_prepbuffer (use System.String concatenation or similar) + luaL_pushresult (use System.String concatenation or similar) + luaL_register (all libs already opened, use require in scripts for external libs) + luaL_typerror (function argument checking unnecessary) + + (complete lua_Debug interface omitted) + lua_gethook*** + lua_getinfo + lua_getlocal + lua_getstack + lua_getupvalue + lua_sethook + lua_setlocal + lua_setupvalue + */ + public class LuaDLL + { + // for debugging + // const string BASEPATH = @"C:\development\software\dotnet\tools\PulseRecognizer\PulseRecognizer\bin\Debug\"; + // const string BASEPATH = @"C:\development\software\ThirdParty\lua\Built\"; + const string LUADLL = "lua51.dll"; + const string LUALIBDLL = LUADLL; + const string STUBDLL = LUADLL; + + // steffenj: BEGIN additional Lua API functions new in Lua 5.1 + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern int lua_gc(IntPtr luaState, LuaGCOptions what, int data); + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern string lua_typename(IntPtr luaState, LuaTypes type); + public static string luaL_typename(IntPtr luaState, int stackPos) + { + return LuaDLL.lua_typename(luaState, LuaDLL.lua_type(luaState, stackPos)); + } + + [DllImport(LUALIBDLL, CallingConvention = CallingConvention.Cdecl)] + public static extern void luaL_error(IntPtr luaState, string message); + [DllImport(LUALIBDLL, CallingConvention = CallingConvention.Cdecl)] + public static extern string luaL_gsub(IntPtr luaState, string str, string pattern, string replacement); + + // the functions below are still untested + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern void lua_getfenv(IntPtr luaState, int stackPos); + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern int lua_isfunction(IntPtr luaState, int stackPos); + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern int lua_islightuserdata(IntPtr luaState, int stackPos); + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern int lua_istable(IntPtr luaState, int stackPos); + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern int lua_isuserdata(IntPtr luaState, int stackPos); + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern int lua_lessthan(IntPtr luaState, int stackPos1, int stackPos2); + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern int lua_rawequal(IntPtr luaState, int stackPos1, int stackPos2); + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern int lua_setfenv(IntPtr luaState, int stackPos); + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern void lua_setfield(IntPtr luaState, int stackPos, string name); + [DllImport(LUALIBDLL, CallingConvention = CallingConvention.Cdecl)] + public static extern int luaL_callmeta(IntPtr luaState, int stackPos, string name); + // steffenj: END additional Lua API functions new in Lua 5.1 + + // steffenj: BEGIN Lua 5.1.1 API change (lua_open replaced by luaL_newstate) + [DllImport(LUALIBDLL, CallingConvention = CallingConvention.Cdecl)] + public static extern IntPtr luaL_newstate(); + /// DEPRECATED - use luaL_newstate() instead! + public static IntPtr lua_open() + { + return LuaDLL.luaL_newstate(); + } + // steffenj: END Lua 5.1.1 API change (lua_open replaced by luaL_newstate) + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern void lua_close(IntPtr luaState); + // steffenj: BEGIN Lua 5.1.1 API change (new function luaL_openlibs) + [DllImport(LUALIBDLL, CallingConvention = CallingConvention.Cdecl)] + public static extern void luaL_openlibs(IntPtr luaState); + /* + [DllImport(LUALIBDLL, CallingConvention = CallingConvention.Cdecl)] + public static extern void luaopen_base(IntPtr luaState); + [DllImport(LUALIBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void luaopen_io(IntPtr luaState); + [DllImport(LUALIBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void luaopen_table(IntPtr luaState); + [DllImport(LUALIBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void luaopen_string(IntPtr luaState); + [DllImport(LUALIBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void luaopen_math(IntPtr luaState); + [DllImport(LUALIBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void luaopen_debug(IntPtr luaState); + [DllImport(LUALIBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void luaopen_loadlib(IntPtr luaState); + */ + // steffenj: END Lua 5.1.1 API change (new function luaL_openlibs) + // steffenj: BEGIN Lua 5.1.1 API change (lua_strlen is now lua_objlen) + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern int lua_objlen(IntPtr luaState, int stackPos); + /// DEPRECATED - use lua_objlen(IntPtr luaState, int stackPos) instead! + public static int lua_strlen(IntPtr luaState, int stackPos) + { + return lua_objlen(luaState, stackPos); + } + // steffenj: END Lua 5.1.1 API change (lua_strlen is now lua_objlen) + // steffenj: BEGIN Lua 5.1.1 API change (lua_dostring is now a macro luaL_dostring) + [DllImport(LUALIBDLL, CallingConvention = CallingConvention.Cdecl)] + public static extern int luaL_loadstring(IntPtr luaState, string chunk); + public static int luaL_dostring(IntPtr luaState, string chunk) + { + int result = LuaDLL.luaL_loadstring(luaState, chunk); + if (result != 0) + return result; + + return LuaDLL.lua_pcall(luaState, 0, -1, 0); + } + /// DEPRECATED - use luaL_dostring(IntPtr luaState, string chunk) instead! + public static int lua_dostring(IntPtr luaState, string chunk) + { + return LuaDLL.luaL_dostring(luaState, chunk); + } + // steffenj: END Lua 5.1.1 API change (lua_dostring is now a macro luaL_dostring) + // steffenj: BEGIN Lua 5.1.1 API change (lua_newtable is gone, lua_createtable is new) + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern void lua_createtable(IntPtr luaState, int narr, int nrec); + public static void lua_newtable(IntPtr luaState) + { + LuaDLL.lua_createtable(luaState, 0, 0); + } + // steffenj: END Lua 5.1.1 API change (lua_newtable is gone, lua_createtable is new) + // steffenj: BEGIN Lua 5.1.1 API change (lua_dofile now in LuaLib as luaL_dofile macro) + //[DllImport(LUALIBDLL, CallingConvention = CallingConvention.Cdecl)] + public static int luaL_dofile(IntPtr luaState, string fileName) + { + int result = LuaDLL.luaL_loadfile(luaState, fileName); + if (result != 0) + return result; + + return LuaDLL.lua_pcall(luaState, 0, -1, 0); + } + // steffenj: END Lua 5.1.1 API change (lua_dofile now in LuaLib as luaL_dofile) + public static void lua_getglobal(IntPtr luaState, string name) + { + LuaDLL.lua_pushstring(luaState,name); + LuaDLL.lua_gettable(luaState,LuaIndexes.LUA_GLOBALSINDEX); + } + public static void lua_setglobal(IntPtr luaState, string name) + { + LuaDLL.lua_pushstring(luaState,name); + LuaDLL.lua_insert(luaState,-2); + LuaDLL.lua_settable(luaState,LuaIndexes.LUA_GLOBALSINDEX); + } + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_settop(IntPtr luaState, int newTop); + // steffenj: BEGIN added lua_pop "macro" + public static void lua_pop(IntPtr luaState, int amount) + { + LuaDLL.lua_settop(luaState, -(amount) - 1); + } + // steffenj: END added lua_pop "macro" + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern void lua_insert(IntPtr luaState, int newTop); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_remove(IntPtr luaState, int index); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_gettable(IntPtr luaState, int index); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_rawget(IntPtr luaState, int index); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_settable(IntPtr luaState, int index); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_rawset(IntPtr luaState, int index); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_setmetatable(IntPtr luaState, int objIndex); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern int lua_getmetatable(IntPtr luaState, int objIndex); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern int lua_equal(IntPtr luaState, int index1, int index2); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_pushvalue(IntPtr luaState, int index); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_replace(IntPtr luaState, int index); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern int lua_gettop(IntPtr luaState); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern LuaTypes lua_type(IntPtr luaState, int index); + public static bool lua_isnil(IntPtr luaState, int index) + { + return (LuaDLL.lua_type(luaState,index)==LuaTypes.LUA_TNIL); + } + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern bool lua_isnumber(IntPtr luaState, int index); + public static bool lua_isboolean(IntPtr luaState, int index) + { + return LuaDLL.lua_type(luaState,index)==LuaTypes.LUA_TBOOLEAN; + } + [DllImport(LUALIBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern int luaL_ref(IntPtr luaState, int registryIndex); + public static int lua_ref(IntPtr luaState, int lockRef) + { + if(lockRef!=0) + { + return LuaDLL.luaL_ref(luaState,LuaIndexes.LUA_REGISTRYINDEX); + } + else return 0; + } + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_rawgeti(IntPtr luaState, int tableIndex, int index); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_rawseti(IntPtr luaState, int tableIndex, int index); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern IntPtr lua_newuserdata(IntPtr luaState, int size); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern IntPtr lua_touserdata(IntPtr luaState, int index); + public static void lua_getref(IntPtr luaState, int reference) + { + LuaDLL.lua_rawgeti(luaState,LuaIndexes.LUA_REGISTRYINDEX,reference); + } + [DllImport(LUALIBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void luaL_unref(IntPtr luaState, int registryIndex, int reference); + public static void lua_unref(IntPtr luaState, int reference) + { + LuaDLL.luaL_unref(luaState,LuaIndexes.LUA_REGISTRYINDEX,reference); + } + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern bool lua_isstring(IntPtr luaState, int index); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern bool lua_iscfunction(IntPtr luaState, int index); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_pushnil(IntPtr luaState); + [DllImport(STUBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_pushstdcallcfunction(IntPtr luaState, [MarshalAs(UnmanagedType.FunctionPtr)]LuaCSFunction function); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern int lua_call(IntPtr luaState, int nArgs, int nResults); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern int lua_pcall(IntPtr luaState, int nArgs, int nResults, int errfunc); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern int lua_rawcall(IntPtr luaState, int nArgs, int nResults); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern IntPtr lua_tocfunction(IntPtr luaState, int index); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern double lua_tonumber(IntPtr luaState, int index); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern bool lua_toboolean(IntPtr luaState, int index); + + [DllImport(LUADLL,CallingConvention = CallingConvention.Cdecl)] + public static extern IntPtr lua_tolstring(IntPtr luaState, int index, out int strLen); + + public static string lua_tostring(IntPtr luaState, int index) + { + int strlen; + + IntPtr str = lua_tolstring(luaState, index, out strlen); + if (str != IntPtr.Zero) + return Marshal.PtrToStringAnsi(str, strlen); + else + return null; // treat lua nulls to as C# nulls + } + + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern void lua_atpanic(IntPtr luaState, LuaFunctionCallback panicf); + + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_pushnumber(IntPtr luaState, double number); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_pushboolean(IntPtr luaState, bool value); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_pushlstring(IntPtr luaState, string str, int size); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_pushstring(IntPtr luaState, string str); + [DllImport(LUALIBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern int luaL_newmetatable(IntPtr luaState, string meta); + // steffenj: BEGIN Lua 5.1.1 API change (luaL_getmetatable is now a macro using lua_getfield) + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern void lua_getfield(IntPtr luaState, int stackPos, string meta); + public static void luaL_getmetatable(IntPtr luaState, string meta) + { + LuaDLL.lua_getfield(luaState, LuaIndexes.LUA_REGISTRYINDEX, meta); + } + // steffenj: END Lua 5.1.1 API change (luaL_getmetatable is now a macro using lua_getfield) + [DllImport(LUALIBDLL, CallingConvention = CallingConvention.Cdecl)] + public static extern IntPtr luaL_checkudata(IntPtr luaState, int stackPos, string meta); + [DllImport(LUALIBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern bool luaL_getmetafield(IntPtr luaState, int stackPos, string field); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern int lua_load(IntPtr luaState, LuaChunkReader chunkReader, ref ReaderInfo data, string chunkName); + [DllImport(LUALIBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern int luaL_loadbuffer(IntPtr luaState, string buff, int size, string name); + [DllImport(LUALIBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern int luaL_loadfile(IntPtr luaState, string filename); + [DllImport(STUBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern bool luaL_checkmetatable(IntPtr luaState,int obj); + [DllImport(STUBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern int luanet_tonetobject(IntPtr luaState,int obj); + [DllImport(STUBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern int luanet_newudata(IntPtr luaState,int val); + [DllImport(STUBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern int luanet_rawnetobj(IntPtr luaState,int obj); + [DllImport(STUBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern int luanet_checkudata(IntPtr luaState,int obj,string meta); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_error(IntPtr luaState); + [DllImport(LUADLL, CallingConvention = CallingConvention.Cdecl)] + public static extern bool lua_checkstack(IntPtr luaState,int extra); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern int lua_next(IntPtr luaState,int index); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void lua_pushlightuserdata(IntPtr luaState, IntPtr udata); + [DllImport(STUBDLL,CallingConvention=CallingConvention.Cdecl)] + public static extern IntPtr luanet_gettag(); + [DllImport(LUADLL,CallingConvention=CallingConvention.Cdecl)] + public static extern void luaL_where (IntPtr luaState, int level); + } +} diff --git a/LuaInterface/LuaException.cs b/LuaInterface/LuaException.cs new file mode 100644 index 0000000000..1393e6a989 --- /dev/null +++ b/LuaInterface/LuaException.cs @@ -0,0 +1,29 @@ +using System; +using System.Runtime.Serialization; + +namespace LuaInterface +{ + /// + /// Exceptions thrown by the Lua runtime + /// + [Serializable] + public class LuaException : Exception + { + public LuaException() + {} + + public LuaException(string message) : base(message) + {} + + public LuaException(string message, Exception innerException) : base(message, innerException) + {} + + protected LuaException(SerializationInfo info, StreamingContext context) : base(info, context) + {} + + public override string ToString() + { + return Message; + } + } +} diff --git a/LuaInterface/LuaFunction.cs b/LuaInterface/LuaFunction.cs new file mode 100644 index 0000000000..2ef89a1ab4 --- /dev/null +++ b/LuaInterface/LuaFunction.cs @@ -0,0 +1,115 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace LuaInterface +{ + public class LuaFunction : LuaBase + { + //private Lua interpreter; + internal LuaCSFunction function; + //internal int reference; + + public LuaFunction(int reference, Lua interpreter) + { + _Reference = reference; + this.function = null; + _Interpreter = interpreter; + } + + public LuaFunction(LuaCSFunction function, Lua interpreter) + { + _Reference = 0; + this.function = function; + _Interpreter = interpreter; + } + + //~LuaFunction() + //{ + // if (reference != 0) + // interpreter.dispose(reference); + //} + + //bool disposed = false; + //~LuaFunction() + //{ + // Dispose(false); + //} + + //public void Dispose() + //{ + // Dispose(true); + // GC.SuppressFinalize(this); + //} + + //public virtual void Dispose(bool disposeManagedResources) + //{ + // if (!this.disposed) + // { + // if (disposeManagedResources) + // { + // if (_Reference != 0) + // _Interpreter.dispose(_Reference); + // } + + // disposed = true; + // } + //} + + + /* + * Calls the function casting return values to the types + * in returnTypes + */ + internal object[] call(object[] args, Type[] returnTypes) + { + return _Interpreter.callFunction(this, args, returnTypes); + } + /* + * Calls the function and returns its return values inside + * an array + */ + public object[] Call(params object[] args) + { + return _Interpreter.callFunction(this, args); + } + /* + * Pushes the function into the Lua stack + */ + internal void push(IntPtr luaState) + { + if (_Reference != 0) + LuaDLL.lua_getref(luaState, _Reference); + else + _Interpreter.pushCSFunction(function); + } + public override string ToString() + { + return "function"; + } + public override bool Equals(object o) + { + if (o is LuaFunction) + { + LuaFunction l = (LuaFunction)o; + if (this._Reference != 0 && l._Reference != 0) + return _Interpreter.compareRef(l._Reference, this._Reference); + else + return this.function == l.function; + } + else return false; + } + + public override int GetHashCode() + { + if (_Reference != 0) + // elisee: Used to return _Reference + // which doesn't make sense as you can have different refs + // to the same function + return 0; + else + return function.GetHashCode(); + } + } + +} diff --git a/LuaInterface/LuaGlobalAttribute.cs b/LuaInterface/LuaGlobalAttribute.cs new file mode 100644 index 0000000000..f444f10ec1 --- /dev/null +++ b/LuaInterface/LuaGlobalAttribute.cs @@ -0,0 +1,23 @@ +using System; + +namespace LuaInterface +{ + /// + /// Marks a method for global usage in Lua scripts + /// + /// + /// + [AttributeUsage(AttributeTargets.Method)] + public sealed class LuaGlobalAttribute : Attribute + { + /// + /// An alternative name to use for calling the function in Lua - leave empty for CLR name + /// + public string Name { get; set; } + + /// + /// A description of the function + /// + public string Description { get; set; } + } +} diff --git a/LuaInterface/LuaHideAttribute.cs b/LuaInterface/LuaHideAttribute.cs new file mode 100644 index 0000000000..854f5de78b --- /dev/null +++ b/LuaInterface/LuaHideAttribute.cs @@ -0,0 +1,11 @@ +using System; + +namespace LuaInterface +{ + /// + /// Marks a method, field or property to be hidden from Lua auto-completion + /// + [AttributeUsage(AttributeTargets.Method | AttributeTargets.Field | AttributeTargets.Property)] + public sealed class LuaHideAttribute : Attribute + {} +} diff --git a/LuaInterface/LuaInterface.csproj b/LuaInterface/LuaInterface.csproj new file mode 100644 index 0000000000..9098fd212a --- /dev/null +++ b/LuaInterface/LuaInterface.csproj @@ -0,0 +1,47 @@ + + + + {E915A0A4-2641-4F7E-8A88-8F123FA88BF1} + v3.5 + Client + + + ..\ + + + Library + + + + + + + + + + + + + + + + + + + + + + + + + + + + {bdaeab25-991e-46a7-af1e-4f0e03358daa} + OpenRA.FileFormats + + + + + + \ No newline at end of file diff --git a/LuaInterface/LuaRegistrationHelper.cs b/LuaInterface/LuaRegistrationHelper.cs new file mode 100644 index 0000000000..9e3fc0fa5a --- /dev/null +++ b/LuaInterface/LuaRegistrationHelper.cs @@ -0,0 +1,90 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using System.Reflection; + +namespace LuaInterface +{ + public static class LuaRegistrationHelper + { + #region Tagged instance methods + /// + /// Registers all public instance methods in an object tagged with as Lua global functions + /// + /// The Lua VM to add the methods to + /// The object to get the methods from + public static void TaggedInstanceMethods(Lua lua, object o) + { + #region Sanity checks + if (lua == null) throw new ArgumentNullException("lua"); + if (o == null) throw new ArgumentNullException("o"); + #endregion + + foreach (MethodInfo method in o.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public)) + { + foreach (LuaGlobalAttribute attribute in method.GetCustomAttributes(typeof(LuaGlobalAttribute), true)) + { + if (string.IsNullOrEmpty(attribute.Name)) + lua.RegisterFunction(method.Name, o, method); // CLR name + else + lua.RegisterFunction(attribute.Name, o, method); // Custom name + } + } + } + #endregion + + #region Tagged static methods + /// + /// Registers all public static methods in a class tagged with as Lua global functions + /// + /// The Lua VM to add the methods to + /// The class type to get the methods from + public static void TaggedStaticMethods(Lua lua, Type type) + { + #region Sanity checks + if (lua == null) throw new ArgumentNullException("lua"); + if (type == null) throw new ArgumentNullException("type"); + if (!type.IsClass) throw new ArgumentException("The type must be a class!", "type"); + #endregion + + foreach (MethodInfo method in type.GetMethods(BindingFlags.Static | BindingFlags.Public)) + { + foreach (LuaGlobalAttribute attribute in method.GetCustomAttributes(typeof(LuaGlobalAttribute), false)) + { + if (string.IsNullOrEmpty(attribute.Name)) + lua.RegisterFunction(method.Name, null, method); // CLR name + else + lua.RegisterFunction(attribute.Name, null, method); // Custom name + } + } + } + #endregion + + #region Enumeration + /// + /// Registers an enumeration's values for usage as a Lua variable table + /// + /// The enum type to register + /// The Lua VM to add the enum to + [SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Justification = "The type parameter is used to select an enum type")] + public static void Enumeration(Lua lua) + { + #region Sanity checks + if (lua == null) throw new ArgumentNullException("lua"); + #endregion + + Type type = typeof(T); + if (!type.IsEnum) throw new ArgumentException("The type must be an enumeration!"); + + string[] names = Enum.GetNames(type); + T[] values = (T[])Enum.GetValues(type); + + lua.NewTable(type.Name); + for (int i = 0; i < names.Length; i++) + { + string path = type.Name + "." + names[i]; + lua[path] = values[i]; + } + } + #endregion + } +} diff --git a/LuaInterface/LuaScriptException.cs b/LuaInterface/LuaScriptException.cs new file mode 100644 index 0000000000..6b45a0ca7e --- /dev/null +++ b/LuaInterface/LuaScriptException.cs @@ -0,0 +1,50 @@ +using System; + +namespace LuaInterface +{ + /// + /// Exceptions thrown by the Lua runtime because of errors in the script + /// + public class LuaScriptException : LuaException + { + /// + /// Returns true if the exception has occured as the result of a .NET exception in user code + /// + public bool IsNetException { get; private set; } + + private readonly string source; + + /// + /// The position in the script where the exception was triggered. + /// + public override string Source { get { return source; } } + + /// + /// Creates a new Lua-only exception. + /// + /// The message that describes the error. + /// The position in the script where the exception was triggered. + public LuaScriptException(string message, string source) : base(message) + { + this.source = source; + } + + /// + /// Creates a new .NET wrapping exception. + /// + /// The .NET exception triggered by user-code. + /// The position in the script where the exception was triggered. + public LuaScriptException(Exception innerException, string source) + : base(innerException.Message, innerException) + { + this.source = source; + this.IsNetException = true; + } + + public override string ToString() + { + // Prepend the error source + return GetType().FullName + ": " + source + Message; + } + } +} diff --git a/LuaInterface/LuaTable.cs b/LuaInterface/LuaTable.cs new file mode 100644 index 0000000000..d9fb67c47d --- /dev/null +++ b/LuaInterface/LuaTable.cs @@ -0,0 +1,145 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Collections; + +namespace LuaInterface +{ + /* + * Wrapper class for Lua tables + * + * Author: Fabio Mascarenhas + * Version: 1.0 + */ + public class LuaTable : LuaBase + { + public bool IsOrphaned; + + //internal int _Reference; + //private Lua _Interpreter; + public LuaTable(int reference, Lua interpreter) + { + _Reference = reference; + _Interpreter = interpreter; + } + + //bool disposed = false; + //~LuaTable() + //{ + // Dispose(false); + //} + + //public void Dispose() + //{ + // Dispose(true); + // GC.SuppressFinalize(this); + //} + + //public virtual void Dispose(bool disposeManagedResources) + //{ + // if (!this.disposed) + // { + // if (disposeManagedResources) + // { + // if (_Reference != 0) + // _Interpreter.dispose(_Reference); + // } + + // disposed = true; + // } + //} + //~LuaTable() + //{ + // _Interpreter.dispose(_Reference); + //} + /* + * Indexer for string fields of the table + */ + public object this[string field] + { + get + { + return _Interpreter.getObject(_Reference, field); + } + set + { + _Interpreter.setObject(_Reference, field, value); + } + } + /* + * Indexer for numeric fields of the table + */ + public object this[object field] + { + get + { + return _Interpreter.getObject(_Reference, field); + } + set + { + _Interpreter.setObject(_Reference, field, value); + } + } + + + public System.Collections.IDictionaryEnumerator GetEnumerator() + { + return _Interpreter.GetTableDict(this).GetEnumerator(); + } + + public ICollection Keys + { + get { return _Interpreter.GetTableDict(this).Keys; } + } + + public ICollection Values + { + get { return _Interpreter.GetTableDict(this).Values; } + } + + /* + * Gets an string fields of a table ignoring its metatable, + * if it exists + */ + internal object rawget(string field) + { + return _Interpreter.rawGetObject(_Reference, field); + } + + internal object rawgetFunction(string field) + { + object obj = _Interpreter.rawGetObject(_Reference, field); + + if (obj is LuaCSFunction) + return new LuaFunction((LuaCSFunction)obj, _Interpreter); + else + return obj; + } + + /* + * Pushes this table into the Lua stack + */ + internal void push(IntPtr luaState) + { + LuaDLL.lua_getref(luaState, _Reference); + } + public override string ToString() + { + return "table"; + } + + //public override bool Equals(object o) + //{ + // if (o is LuaTable) + // { + // LuaTable l = (LuaTable)o; + // return _Interpreter.compareRef(l._Reference, _Reference); + // } + // else return false; + //} + //public override int GetHashCode() + //{ + // return _Reference; + //} + } +} diff --git a/LuaInterface/LuaUserData.cs b/LuaInterface/LuaUserData.cs new file mode 100644 index 0000000000..17b3e75505 --- /dev/null +++ b/LuaInterface/LuaUserData.cs @@ -0,0 +1,82 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace LuaInterface +{ + public class LuaUserData : LuaBase + { + //internal int _Reference; + //private Lua _Interpreter; + public LuaUserData(int reference, Lua interpreter) + { + _Reference = reference; + _Interpreter = interpreter; + } + //~LuaUserData() + //{ + // if (_Reference != 0) + // _Interpreter.dispose(_Reference); + //} + /* + * Indexer for string fields of the userdata + */ + public object this[string field] + { + get + { + return _Interpreter.getObject(_Reference, field); + } + set + { + _Interpreter.setObject(_Reference, field, value); + } + } + /* + * Indexer for numeric fields of the userdata + */ + public object this[object field] + { + get + { + return _Interpreter.getObject(_Reference, field); + } + set + { + _Interpreter.setObject(_Reference, field, value); + } + } + /* + * Calls the userdata and returns its return values inside + * an array + */ + public object[] Call(params object[] args) + { + return _Interpreter.callFunction(this, args); + } + /* + * Pushes the userdata into the Lua stack + */ + internal void push(IntPtr luaState) + { + LuaDLL.lua_getref(luaState, _Reference); + } + public override string ToString() + { + return "userdata"; + } + //public override bool Equals(object o) + //{ + // if (o is LuaUserData) + // { + // LuaUserData l = (LuaUserData)o; + // return _Interpreter.compareRef(l._Reference, _Reference); + // } + // else return false; + //} + //public override int GetHashCode() + //{ + // return _Reference; + //} + } +} diff --git a/LuaInterface/Metatables.cs b/LuaInterface/Metatables.cs new file mode 100644 index 0000000000..630ea6791e --- /dev/null +++ b/LuaInterface/Metatables.cs @@ -0,0 +1,935 @@ +namespace LuaInterface +{ + using System; + using System.IO; + using System.Collections; + using System.Reflection; + using System.Diagnostics; + using System.Collections.Generic; + using System.Runtime.InteropServices; + + /* + * Functions used in the metatables of userdata representing + * CLR objects + * + * Author: Fabio Mascarenhas + * Version: 1.0 + */ + class MetaFunctions + { + /* + * __index metafunction for CLR objects. Implemented in Lua. + */ + internal static string luaIndexFunction = + @" + local function index(obj,name) + local meta=getmetatable(obj) + local cached=meta.cache[name] + if cached then + return cached + else + local value,isFunc = get_object_member(obj,name) + if value==nil and type(isFunc)=='string' then error(isFunc,2) end + if isFunc then + meta.cache[name]=value + end + return value + end + end + return index"; + + private ObjectTranslator translator; + private Hashtable memberCache = new Hashtable(); + internal LuaCSFunction gcFunction, indexFunction, newindexFunction, + baseIndexFunction, classIndexFunction, classNewindexFunction, + execDelegateFunction, callConstructorFunction, toStringFunction; + + public MetaFunctions(ObjectTranslator translator) + { + this.translator = translator; + gcFunction = new LuaCSFunction(this.collectObject); + toStringFunction = new LuaCSFunction(this.toString); + indexFunction = new LuaCSFunction(this.getMethod); + newindexFunction = new LuaCSFunction(this.setFieldOrProperty); + baseIndexFunction = new LuaCSFunction(this.getBaseMethod); + callConstructorFunction = new LuaCSFunction(this.callConstructor); + classIndexFunction = new LuaCSFunction(this.getClassMethod); + classNewindexFunction = new LuaCSFunction(this.setClassFieldOrProperty); + execDelegateFunction = new LuaCSFunction(this.runFunctionDelegate); + } + + /* + * __call metafunction of CLR delegates, retrieves and calls the delegate. + */ + private int runFunctionDelegate(IntPtr luaState) + { + LuaCSFunction func = (LuaCSFunction)translator.getRawNetObject(luaState, 1); + LuaDLL.lua_remove(luaState, 1); + return func(luaState); + } + /* + * __gc metafunction of CLR objects. + */ + private int collectObject(IntPtr luaState) + { + int udata = LuaDLL.luanet_rawnetobj(luaState, 1); + if (udata != -1) + { + translator.collectObject(udata); + } + else + { + // Debug.WriteLine("not found: " + udata); + } + return 0; + } + /* + * __tostring metafunction of CLR objects. + */ + private int toString(IntPtr luaState) + { + object obj = translator.getRawNetObject(luaState, 1); + if (obj != null) + { + translator.push(luaState, obj.ToString() + ": " + obj.GetHashCode()); + } + else LuaDLL.lua_pushnil(luaState); + return 1; + } + + + /// + /// Debug tool to dump the lua stack + /// + /// FIXME, move somewhere else + public static void dumpStack(ObjectTranslator translator, IntPtr luaState) + { + int depth = LuaDLL.lua_gettop(luaState); + + Debug.WriteLine("lua stack depth: " + depth); + for (int i = 1; i <= depth; i++) + { + LuaTypes type = LuaDLL.lua_type(luaState, i); + // we dump stacks when deep in calls, calling typename while the stack is in flux can fail sometimes, so manually check for key types + string typestr = (type == LuaTypes.LUA_TTABLE) ? "table" : LuaDLL.lua_typename(luaState, type); + + string strrep = LuaDLL.lua_tostring(luaState, i); + if (type == LuaTypes.LUA_TUSERDATA) + { + object obj = translator.getRawNetObject(luaState, i); + strrep = obj.ToString(); + } + + Debug.Print("{0}: ({1}) {2}", i, typestr, strrep); + } + } + + /* + * Called by the __index metafunction of CLR objects in case the + * method is not cached or it is a field/property/event. + * Receives the object and the member name as arguments and returns + * either the value of the member or a delegate to call it. + * If the member does not exist returns nil. + */ + private int getMethod(IntPtr luaState) + { + object obj = translator.getRawNetObject(luaState, 1); + if (obj == null) + { + translator.throwError(luaState, "trying to index an invalid object reference"); + LuaDLL.lua_pushnil(luaState); + return 1; + } + + object index = translator.getObject(luaState, 2); + + string methodName = index as string; // will be null if not a string arg + Type objType = obj.GetType(); + + // Handle the most common case, looking up the method by name. + + // CP: This will fail when using indexers and attempting to get a value with the same name as a property of the object, + // ie: xmlelement['item'] <- item is a property of xmlelement + try + { + if (methodName != null && isMemberPresent(objType, methodName)) + return getMember(luaState, objType, obj, methodName, BindingFlags.Instance | BindingFlags.IgnoreCase); + } + catch { } + bool failed = true; + + // Try to access by array if the type is right and index is an int (lua numbers always come across as double) + if (objType.IsArray && index is double) + { + int intIndex = (int)((double)index); + Array aa = obj as Array; + if (intIndex >= aa.Length) { + return translator.pushError(luaState,"array index out of bounds: "+intIndex + " " + aa.Length); + } + object val = aa.GetValue(intIndex); + translator.push (luaState,val); + failed = false; + } + else + { + // Try to use get_Item to index into this .net object + //MethodInfo getter = objType.GetMethod("get_Item"); + // issue here is that there may be multiple indexers.. + MethodInfo[] methods = objType.GetMethods(); + + foreach (MethodInfo mInfo in methods) + { + if (mInfo.Name == "get_Item") + { + //check if the signature matches the input + if (mInfo.GetParameters().Length == 1) + { + MethodInfo getter = mInfo; + ParameterInfo[] actualParms = (getter != null) ? getter.GetParameters() : null; + if (actualParms == null || actualParms.Length != 1) + { + return translator.pushError(luaState, "method not found (or no indexer): " + index); + } + else + { + // Get the index in a form acceptable to the getter + index = translator.getAsType(luaState, 2, actualParms[0].ParameterType); + // Just call the indexer - if out of bounds an exception will happen + try + { + object result = getter.Invoke(obj, new object[]{index}); + translator.push(luaState, result); + failed = false; + } + catch (TargetInvocationException e) + { + // Provide a more readable description for the common case of key not found + if (e.InnerException is KeyNotFoundException) + return translator.pushError(luaState, "key '" + index + "' not found "); + else + return translator.pushError(luaState, "exception indexing '" + index + "' " + e.Message); + + + } + } + } + } + } + + + } + if (failed) { + return translator.pushError(luaState,"cannot find " + index); + } + LuaDLL.lua_pushboolean(luaState, false); + return 2; + } + + + /* + * __index metafunction of base classes (the base field of Lua tables). + * Adds a prefix to the method name to call the base version of the method. + */ + private int getBaseMethod(IntPtr luaState) + { + object obj = translator.getRawNetObject(luaState, 1); + if (obj == null) + { + translator.throwError(luaState, "trying to index an invalid object reference"); + LuaDLL.lua_pushnil(luaState); + LuaDLL.lua_pushboolean(luaState, false); + return 2; + } + string methodName = LuaDLL.lua_tostring(luaState, 2); + if (methodName == null) + { + LuaDLL.lua_pushnil(luaState); + LuaDLL.lua_pushboolean(luaState, false); + return 2; + } + getMember(luaState, obj.GetType(), obj, "__luaInterface_base_" + methodName, BindingFlags.Instance | BindingFlags.IgnoreCase); + LuaDLL.lua_settop(luaState, -2); + if (LuaDLL.lua_type(luaState, -1) == LuaTypes.LUA_TNIL) + { + LuaDLL.lua_settop(luaState, -2); + return getMember(luaState, obj.GetType(), obj, methodName, BindingFlags.Instance | BindingFlags.IgnoreCase); + } + LuaDLL.lua_pushboolean(luaState, false); + return 2; + } + + + /// + /// Does this method exist as either an instance or static? + /// + /// + /// + /// + bool isMemberPresent(IReflect objType, string methodName) + { + object cachedMember = checkMemberCache(memberCache, objType, methodName); + + if (cachedMember != null) + return true; + + //CP: Removed NonPublic binding search + MemberInfo[] members = objType.GetMember(methodName, BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase/* | BindingFlags.NonPublic*/); + return (members.Length > 0); + } + + /* + * 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). + */ + private int getMember(IntPtr luaState, IReflect objType, object obj, string methodName, BindingFlags bindingType) + { + bool implicitStatic = false; + MemberInfo member = null; + object cachedMember = checkMemberCache(memberCache, objType, methodName); + //object cachedMember=null; + if (cachedMember is LuaCSFunction) + { + translator.pushFunction(luaState, (LuaCSFunction)cachedMember); + translator.push(luaState, true); + return 2; + } + else if (cachedMember != null) + { + member = (MemberInfo)cachedMember; + } + else + { + //CP: Removed NonPublic binding search + MemberInfo[] members = objType.GetMember(methodName, bindingType | BindingFlags.Public | BindingFlags.IgnoreCase/*| BindingFlags.NonPublic*/); + 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 + // lookups for fields/properties/events -kevinh + //CP: Removed NonPublic binding search and made case insensitive + members = objType.GetMember(methodName, bindingType | BindingFlags.Static | BindingFlags.Public | BindingFlags.IgnoreCase/*| BindingFlags.NonPublic*/); + + if (members.Length > 0) + { + member = members[0]; + implicitStatic = true; + } + } + } + if (member != null) + { + if (member.MemberType == MemberTypes.Field) + { + FieldInfo field = (FieldInfo)member; + if (cachedMember == null) setMemberCache(memberCache, objType, methodName, member); + try + { + translator.push(luaState, field.GetValue(obj)); + } + catch + { + LuaDLL.lua_pushnil(luaState); + } + } + else if (member.MemberType == MemberTypes.Property) + { + PropertyInfo 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 + LuaDLL.lua_pushnil(luaState); + } + catch (TargetInvocationException e) // Convert this exception into a Lua error + { + ThrowError(luaState, e); + LuaDLL.lua_pushnil(luaState); + } + } + else if (member.MemberType == MemberTypes.Event) + { + EventInfo 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; + Type dectype = member.DeclaringType; + + // Build a new long name and try to find the type by name + string longname = dectype.FullName + "+" + name; + Type nestedType = translator.FindType(longname); + + translator.pushType(luaState, nestedType); + } + else + { + // Member type must be 'method' + LuaCSFunction wrapper = new LuaCSFunction((new LuaMethodWrapper(translator, objType, methodName, bindingType)).call); + + 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); + + LuaDLL.lua_pushnil(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); + + LuaDLL.lua_pushnil(luaState); + } + + // push false because we are NOT returning a function (see luaIndexFunction) + translator.push(luaState, false); + return 2; + } + /* + * Checks if a MemberInfo object is cached, returning it or null. + */ + private object checkMemberCache(Hashtable memberCache, IReflect objType, string memberName) + { + Hashtable members = (Hashtable)memberCache[objType]; + if (members != null) + return members[memberName]; + else + return null; + } + /* + * Stores a MemberInfo object in the member cache. + */ + private void setMemberCache(Hashtable memberCache, IReflect objType, string memberName, object member) + { + Hashtable members = (Hashtable)memberCache[objType]; + if (members == null) + { + members = new Hashtable(); + memberCache[objType] = members; + } + members[memberName] = member; + } + /* + * __newindex metafunction of CLR objects. Receives the object, + * the member name and the value to be stored as arguments. Throws + * and error if the assignment is invalid. + */ + private int setFieldOrProperty(IntPtr luaState) + { + object target = translator.getRawNetObject(luaState, 1); + if (target == null) + { + translator.throwError(luaState, "trying to index and invalid object reference"); + return 0; + } + Type type = target.GetType(); + + // First try to look up the parameter as a property name + string detailMessage; + bool didMember = trySetMember(luaState, type, target, BindingFlags.Instance | BindingFlags.IgnoreCase, out detailMessage); + + if (didMember) + return 0; // Must have found the property name + + // We didn't find a property name, now see if we can use a [] style this accessor to set array contents + try + { + if (type.IsArray && LuaDLL.lua_isnumber(luaState, 2)) + { + int index = (int)LuaDLL.lua_tonumber(luaState, 2); + + Array arr = (Array)target; + object val = translator.getAsType(luaState, 3, arr.GetType().GetElementType()); + arr.SetValue(val, index); + } + else + { + // Try to see if we have a this[] accessor + MethodInfo setter = type.GetMethod("set_Item"); + if (setter != null) + { + ParameterInfo[] args = setter.GetParameters(); + Type valueType = args[1].ParameterType; + + // The new val ue the user specified + object val = translator.getAsType(luaState, 3, valueType); + + Type indexType = args[0].ParameterType; + object index = translator.getAsType(luaState, 2, indexType); + + object[] methodArgs = new object[2]; + + // Just call the indexer - if out of bounds an exception will happen + methodArgs[0] = index; + methodArgs[1] = val; + + setter.Invoke(target, methodArgs); + } + else + { + translator.throwError(luaState, detailMessage); // Pass the original message from trySetMember because it is probably best + } + } + } + catch (SEHException) + { + // If we are seeing a C++ exception - this must actually be for Lua's private use. Let it handle it + throw; + } + catch (Exception e) + { + ThrowError(luaState, e); + } + return 0; + } + + /// + /// Tries to set a named property or field + /// + /// + /// + /// + /// + /// false if unable to find the named member, true for success + private bool trySetMember(IntPtr luaState, IReflect targetType, object target, BindingFlags bindingType, out string detailMessage) + { + detailMessage = null; // No error yet + + // If not already a string just return - we don't want to call tostring - which has the side effect of + // changing the lua typecode to string + // Note: We don't use isstring because the standard lua C isstring considers either strings or numbers to + // be true for isstring. + if (LuaDLL.lua_type(luaState, 2) != LuaTypes.LUA_TSTRING) + { + detailMessage = "property names must be strings"; + return false; + } + + // We only look up property names by string + string fieldName = LuaDLL.lua_tostring(luaState, 2); + if (fieldName == null || fieldName.Length < 1 || !(char.IsLetter(fieldName[0]) || fieldName[0] == '_')) + { + detailMessage = "invalid property name"; + return false; + } + + // Find our member via reflection or the cache + MemberInfo member = (MemberInfo)checkMemberCache(memberCache, targetType, fieldName); + if (member == null) + { + //CP: Removed NonPublic binding search and made case insensitive + MemberInfo[] members = targetType.GetMember(fieldName, bindingType | BindingFlags.Public | BindingFlags.IgnoreCase/*| BindingFlags.NonPublic*/); + if (members.Length > 0) + { + member = members[0]; + setMemberCache(memberCache, targetType, fieldName, member); + } + else + { + detailMessage = "field or property '" + fieldName + "' does not exist"; + return false; + } + } + + if (member.MemberType == MemberTypes.Field) + { + FieldInfo field = (FieldInfo)member; + object val = translator.getAsType(luaState, 3, field.FieldType); + try + { + field.SetValue(target, val); + } + catch (Exception e) + { + ThrowError(luaState, e); + } + // We did a call + return true; + } + else if (member.MemberType == MemberTypes.Property) + { + PropertyInfo property = (PropertyInfo)member; + object val = translator.getAsType(luaState, 3, property.PropertyType); + try + { + property.SetValue(target, val, null); + } + catch (Exception e) + { + ThrowError(luaState, e); + } + // We did a call + return true; + } + + detailMessage = "'" + fieldName + "' is not a .net field or property"; + return false; + } + + + /* + * Writes to fields or properties, either static or instance. Throws an error + * if the operation is invalid. + */ + private int setMember(IntPtr luaState, IReflect targetType, object target, BindingFlags bindingType) + { + string detail; + bool success = trySetMember(luaState, targetType, target, bindingType, out detail); + + if (!success) + translator.throwError(luaState, detail); + + return 0; + } + + /// + /// Convert a C# exception into a Lua error + /// + /// + /// We try to look into the exception to give the most meaningful description + void ThrowError(IntPtr luaState, Exception e) + { + // If we got inside a reflection show what really happened + TargetInvocationException te = e as TargetInvocationException; + + if (te != null) + e = te.InnerException; + + translator.throwError(luaState, e); + } + + /* + * __index metafunction of type references, works on static members. + */ + private int getClassMethod(IntPtr luaState) + { + IReflect klass; + object obj = translator.getRawNetObject(luaState, 1); + if (obj == null || !(obj is IReflect)) + { + translator.throwError(luaState, "trying to index an invalid type reference"); + LuaDLL.lua_pushnil(luaState); + return 1; + } + else klass = (IReflect)obj; + if (LuaDLL.lua_isnumber(luaState, 2)) + { + int size = (int)LuaDLL.lua_tonumber(luaState, 2); + translator.push(luaState, Array.CreateInstance(klass.UnderlyingSystemType, size)); + return 1; + } + else + { + string methodName = LuaDLL.lua_tostring(luaState, 2); + if (methodName == null) + { + LuaDLL.lua_pushnil(luaState); + return 1; + } //CP: Ignore case + else return getMember(luaState, klass, null, methodName, BindingFlags.FlattenHierarchy | BindingFlags.Static | BindingFlags.IgnoreCase); + } + } + /* + * __newindex function of type references, works on static members. + */ + private int setClassFieldOrProperty(IntPtr luaState) + { + IReflect target; + object obj = translator.getRawNetObject(luaState, 1); + if (obj == null || !(obj is IReflect)) + { + translator.throwError(luaState, "trying to index an invalid type reference"); + return 0; + } + else target = (IReflect)obj; + return setMember(luaState, target, null, BindingFlags.FlattenHierarchy | BindingFlags.Static | BindingFlags.IgnoreCase); + } + /* + * __call metafunction of type references. Searches for and calls + * a constructor for the type. Returns nil if the constructor is not + * found or if the arguments are invalid. Throws an error if the constructor + * generates an exception. + */ + private int callConstructor(IntPtr luaState) + { + MethodCache validConstructor = new MethodCache(); + IReflect klass; + object obj = translator.getRawNetObject(luaState, 1); + if (obj == null || !(obj is IReflect)) + { + translator.throwError(luaState, "trying to call constructor on an invalid type reference"); + LuaDLL.lua_pushnil(luaState); + return 1; + } + else klass = (IReflect)obj; + LuaDLL.lua_remove(luaState, 1); + ConstructorInfo[] constructors = klass.UnderlyingSystemType.GetConstructors(); + foreach (ConstructorInfo constructor in constructors) + { + bool isConstructor = matchParameters(luaState, constructor, ref validConstructor); + if (isConstructor) + { + try + { + translator.push(luaState, constructor.Invoke(validConstructor.args)); + } + catch (TargetInvocationException e) + { + ThrowError(luaState, e); + LuaDLL.lua_pushnil(luaState); + } + catch + { + LuaDLL.lua_pushnil(luaState); + } + return 1; + } + } + + string constructorName = (constructors.Length == 0) ? "unknown" : constructors[0].Name; + + translator.throwError(luaState, String.Format("{0} does not contain constructor({1}) argument match", + klass.UnderlyingSystemType, + constructorName)); + LuaDLL.lua_pushnil(luaState); + return 1; + } + + private static bool IsInteger(double x) { + return Math.Ceiling(x) == x; + } + + + internal Array TableToArray(object luaParamValue, Type paramArrayType) { + Array paramArray; + + if (luaParamValue is LuaTable) { + LuaTable table = (LuaTable)luaParamValue; + IDictionaryEnumerator tableEnumerator = table.GetEnumerator(); + tableEnumerator.Reset(); + paramArray = Array.CreateInstance(paramArrayType, table.Values.Count); + + int paramArrayIndex = 0; + + while(tableEnumerator.MoveNext()) { + object o = tableEnumerator.Value; + if (paramArrayType == typeof(object)) { + if (o != null && o.GetType() == typeof(double) && IsInteger((double)o)) + o = Convert.ToInt32((double)o); + } + paramArray.SetValue(Convert.ChangeType(o, paramArrayType), paramArrayIndex); + paramArrayIndex++; + } + } else { + paramArray = Array.CreateInstance(paramArrayType, 1); + paramArray.SetValue(luaParamValue, 0); + } + + return paramArray; + + } + + /* + * Matches a method against its arguments in the Lua stack. Returns + * if the match was succesful. It it was also returns the information + * necessary to invoke the method. + */ + internal bool matchParameters(IntPtr luaState, MethodBase method, ref MethodCache methodCache) + { + ExtractValue extractValue; + bool isMethod = true; + ParameterInfo[] paramInfo = method.GetParameters(); + int currentLuaParam = 1; + int nLuaParams = LuaDLL.lua_gettop(luaState); + ArrayList paramList = new ArrayList(); + List outList = new List(); + List argTypes = new List(); + foreach (ParameterInfo currentNetParam in paramInfo) + { + if (!currentNetParam.IsIn && currentNetParam.IsOut) // Skips out params + { + outList.Add(paramList.Add(null)); + } + else if (currentLuaParam > nLuaParams) // Adds optional parameters + { + if (currentNetParam.IsOptional) + { + paramList.Add(currentNetParam.DefaultValue); + } + else + { + isMethod = false; + break; + } + } + else if (_IsTypeCorrect(luaState, currentLuaParam, currentNetParam, out extractValue)) // Type checking + { + int index = paramList.Add(extractValue(luaState, currentLuaParam)); + + MethodArgs methodArg = new MethodArgs(); + methodArg.index = index; + methodArg.extractValue = extractValue; + argTypes.Add(methodArg); + + if (currentNetParam.ParameterType.IsByRef) + outList.Add(index); + currentLuaParam++; + } // Type does not match, ignore if the parameter is optional + else if (_IsParamsArray(luaState, currentLuaParam, currentNetParam, out extractValue)) + { + object luaParamValue = extractValue(luaState, currentLuaParam); + Type paramArrayType = currentNetParam.ParameterType.GetElementType(); + + Array paramArray = TableToArray(luaParamValue, paramArrayType); + int index = paramList.Add(paramArray); + + MethodArgs methodArg = new MethodArgs(); + methodArg.index = index; + methodArg.extractValue = extractValue; + methodArg.isParamsArray = true; + methodArg.paramsArrayType = paramArrayType; + argTypes.Add(methodArg); + + currentLuaParam++; + } + else if (currentNetParam.IsOptional) + { + paramList.Add(currentNetParam.DefaultValue); + } + else // No match + { + isMethod = false; + break; + } + } + if (currentLuaParam != nLuaParams + 1) // Number of parameters does not match + isMethod = false; + if (isMethod) + { + methodCache.args = paramList.ToArray(); + methodCache.cachedMethod = method; + methodCache.outList = outList.ToArray(); + methodCache.argTypes = argTypes.ToArray(); + } + return isMethod; + } + + /// + /// CP: Fix for operator overloading failure + /// Returns true if the type is set and assigns the extract value + /// + /// + /// + /// + /// + /// + private bool _IsTypeCorrect(IntPtr luaState, int currentLuaParam, ParameterInfo currentNetParam, out ExtractValue extractValue) + { + try + { + return (extractValue = translator.typeChecker.checkType(luaState, currentLuaParam, currentNetParam.ParameterType)) != null; + } + catch + { + extractValue = null; + Debug.WriteLine("Type wasn't correct"); + return false; + } + } + + private bool _IsParamsArray(IntPtr luaState, int currentLuaParam, ParameterInfo currentNetParam, out ExtractValue extractValue) + { + extractValue = null; + + if (currentNetParam.GetCustomAttributes(typeof(ParamArrayAttribute), false).Length > 0) + { + LuaTypes luaType; + + try + { + luaType = LuaDLL.lua_type(luaState, currentLuaParam); + } + catch (Exception ex) + { + Debug.WriteLine("Could not retrieve lua type while attempting to determine params Array Status."+ ex.ToString()); + Debug.WriteLine(ex.Message); + extractValue = null; + return false; + } + + if (luaType == LuaTypes.LUA_TTABLE) + { + try + { + extractValue = translator.typeChecker.getExtractor(typeof(LuaTable)); + } + catch (Exception ex) + { + Debug.WriteLine("An error occurred during an attempt to retrieve a LuaTable extractor while checking for params array status." + ex.ToString()); + } + + if (extractValue != null) + { + return true; + } + } + else + { + Type paramElementType = currentNetParam.ParameterType.GetElementType(); + + try + { + extractValue = translator.typeChecker.checkType(luaState, currentLuaParam, paramElementType); + } + catch (Exception ex) + { + Debug.WriteLine(string.Format("An error occurred during an attempt to retrieve an extractor ({0}) while checking for params array status:{1}", paramElementType.FullName,ex.ToString())); + } + + if (extractValue != null) + { + return true; + } + } + } + + Debug.WriteLine("Type wasn't Params object."); + + return false; + } + } +} diff --git a/LuaInterface/MethodWrapper.cs b/LuaInterface/MethodWrapper.cs new file mode 100644 index 0000000000..f572420729 --- /dev/null +++ b/LuaInterface/MethodWrapper.cs @@ -0,0 +1,595 @@ +namespace LuaInterface +{ + using System; + using System.IO; + using System.Collections; + using System.Reflection; + using System.Collections.Generic; + using System.Diagnostics; + + /* + * Cached method + */ + struct MethodCache + { + private MethodBase _cachedMethod; + + public MethodBase cachedMethod + { + get + { + return _cachedMethod; + } + set + { + _cachedMethod = value; + MethodInfo mi = value as MethodInfo; + if (mi != null) + { + //SJD this is guaranteed to be correct irrespective of actual name used for type.. + IsReturnVoid = mi.ReturnType == typeof(void); + } + } + } + + public bool IsReturnVoid; + + // List or arguments + public object[] args; + // Positions of out parameters + public int[] outList; + // Types of parameters + public MethodArgs[] argTypes; + } + + /* + * Parameter information + */ + struct MethodArgs + { + // Position of parameter + public int index; + // Type-conversion function + public ExtractValue extractValue; + + public bool isParamsArray; + + public Type paramsArrayType; + } + + /* + * Argument extraction with type-conversion function + */ + delegate object ExtractValue(IntPtr luaState, int stackPos); + + /* + * Wrapper class for methods/constructors accessed from Lua. + * + * Author: Fabio Mascarenhas + * Version: 1.0 + */ + class LuaMethodWrapper + { + private ObjectTranslator _Translator; + private MethodBase _Method; + private MethodCache _LastCalledMethod = new MethodCache(); + private string _MethodName; + private MemberInfo[] _Members; + private ExtractValue _ExtractTarget; + private object _Target; + private BindingFlags _BindingType; + + /* + * Constructs the wrapper for a known MethodBase instance + */ + public LuaMethodWrapper(ObjectTranslator translator, object target, IReflect targetType, MethodBase method) + { + _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; } + } + /* + * Constructs the wrapper for a known method name + */ + public LuaMethodWrapper(ObjectTranslator translator, IReflect targetType, string methodName, BindingFlags bindingType) + { + _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*/); + } + + + /// + /// Convert C# exceptions into Lua errors + /// + /// num of things on stack + /// null for no pending exception + int SetPendingException(Exception e) + { + return _Translator.interpreter.SetPendingException(e); + } + + private static bool IsInteger(double x) { + return Math.Ceiling(x) == x; + } + + + /* + * Calls the method. Receives the arguments from the Lua stack + * and returns values in it. + */ + public int call(IntPtr luaState) + { + MethodBase methodToCall = _Method; + object targetObject = _Target; + bool failedCall = true; + int nReturnValues = 0; + + if (!LuaDLL.lua_checkstack(luaState, 5)) + throw new LuaException("Lua stack overflow"); + + bool isStatic = (_BindingType & BindingFlags.Static) == BindingFlags.Static; + + SetPendingException(null); + + if (methodToCall == null) // Method from name + { + if (isStatic) + targetObject = null; + else + targetObject = _ExtractTarget(luaState, 1); + + //LuaDLL.lua_remove(luaState,1); // Pops the receiver + if (_LastCalledMethod.cachedMethod != null) // Cached? + { + int numStackToSkip = isStatic ? 0 : 1; // If this is an instance invoe we will have an extra arg on the stack for the targetObject + int numArgsPassed = LuaDLL.lua_gettop(luaState) - numStackToSkip; + MethodBase method = _LastCalledMethod.cachedMethod; + + if (numArgsPassed == _LastCalledMethod.argTypes.Length) // No. of args match? + { + if (!LuaDLL.lua_checkstack(luaState, _LastCalledMethod.outList.Length + 6)) + throw new LuaException("Lua stack overflow"); + + object[] args = _LastCalledMethod.args; + + try + { + for (int i = 0; i < _LastCalledMethod.argTypes.Length; i++) + { + MethodArgs type = _LastCalledMethod.argTypes[i]; + object luaParamValue = type.extractValue(luaState, i + 1 + numStackToSkip); + if (_LastCalledMethod.argTypes[i].isParamsArray) + { + args[type.index] = _Translator.tableToArray(luaParamValue,type.paramsArrayType); + } + else + { + args[type.index] = luaParamValue; + } + + if (args[type.index] == null && + !LuaDLL.lua_isnil(luaState, i + 1 + numStackToSkip)) + { + throw new LuaException("argument number " + (i + 1) + " is invalid"); + } + } + if ((_BindingType & BindingFlags.Static) == BindingFlags.Static) + { + _Translator.push(luaState, method.Invoke(null, args)); + } + else + { + if (_LastCalledMethod.cachedMethod.IsConstructor) + _Translator.push(luaState, ((ConstructorInfo)method).Invoke(args)); + else + _Translator.push(luaState, method.Invoke(targetObject,args)); + } + failedCall = false; + } + catch (TargetInvocationException e) + { + // Failure of method invocation + return SetPendingException(e.GetBaseException()); + } + catch (Exception e) + { + if (_Members.Length == 1) // Is the method overloaded? + // No, throw error + return SetPendingException(e); + } + } + } + + // Cache miss + if (failedCall) + { + // System.Diagnostics.Debug.WriteLine("cache miss on " + methodName); + + // If we are running an instance variable, we can now pop the targetObject from the stack + if (!isStatic) + { + if (targetObject == null) + { + _Translator.throwError(luaState, String.Format("instance method '{0}' requires a non null target object", _MethodName)); + LuaDLL.lua_pushnil(luaState); + return 1; + } + + LuaDLL.lua_remove(luaState, 1); // Pops the receiver + } + + bool hasMatch = false; + string candidateName = null; + + foreach (MemberInfo member in _Members) + { + candidateName = member.ReflectedType.Name + "." + member.Name; + + MethodBase m = (MethodInfo)member; + + bool isMethod = _Translator.matchParameters(luaState, m, ref _LastCalledMethod); + if (isMethod) + { + hasMatch = true; + break; + } + } + if (!hasMatch) + { + string msg = (candidateName == null) + ? "invalid arguments to method call: " + _MethodName + : ("invalid arguments to method: " + candidateName); + + _Translator.throwError(luaState, msg); + LuaDLL.lua_pushnil(luaState); + return 1; + } + } + } + else // Method from MethodBase instance + { + if (methodToCall.ContainsGenericParameters) + { + // bool isMethod = //* not used + _Translator.matchParameters(luaState, methodToCall, ref _LastCalledMethod); + + if (methodToCall.IsGenericMethodDefinition) + { + //need to make a concrete type of the generic method definition + List typeArgs = new List(); + + foreach (object arg in _LastCalledMethod.args) + typeArgs.Add(arg.GetType()); + + MethodInfo concreteMethod = (methodToCall as MethodInfo).MakeGenericMethod(typeArgs.ToArray()); + + _Translator.push(luaState, concreteMethod.Invoke(targetObject, _LastCalledMethod.args)); + failedCall = false; + } + else if (methodToCall.ContainsGenericParameters) + { + _Translator.throwError(luaState, "unable to invoke method on generic class as the current method is an open generic method"); + LuaDLL.lua_pushnil(luaState); + return 1; + } + } + else + { + if (!methodToCall.IsStatic && !methodToCall.IsConstructor && targetObject == null) + { + targetObject = _ExtractTarget(luaState, 1); + LuaDLL.lua_remove(luaState, 1); // Pops the receiver + } + + if (!_Translator.matchParameters(luaState, methodToCall, ref _LastCalledMethod)) + { + _Translator.throwError(luaState, string.Format("invalid arguments to method call {0} of type {1}", methodToCall, methodToCall.ReflectedType)); + LuaDLL.lua_pushnil(luaState); + return 1; + } + } + } + + if (failedCall) + { + if (!LuaDLL.lua_checkstack(luaState, _LastCalledMethod.outList.Length + 6)) + throw new LuaException("Lua stack overflow"); + try + { + if (isStatic) + { + _Translator.push(luaState, _LastCalledMethod.cachedMethod.Invoke(null, _LastCalledMethod.args)); + } + else + { + if (_LastCalledMethod.cachedMethod.IsConstructor) + _Translator.push(luaState, ((ConstructorInfo)_LastCalledMethod.cachedMethod).Invoke(_LastCalledMethod.args)); + else + { + object returnValue = _LastCalledMethod.cachedMethod.Invoke( targetObject, _LastCalledMethod.args ); + _Translator.push(luaState, returnValue ); + + LuaTable returnValueLuaBase = returnValue as LuaTable; + if( returnValueLuaBase != null && returnValueLuaBase.IsOrphaned ) + { + returnValueLuaBase.Dispose(); + } + } + } + } + catch (TargetInvocationException e) + { + return SetPendingException(e.GetBaseException()); + } + catch (Exception e) + { + return SetPendingException(e); + } + } + + // Pushes out and ref return values + for (int index = 0; index < _LastCalledMethod.outList.Length; index++) + { + nReturnValues++; + + object outArg = _LastCalledMethod.args[_LastCalledMethod.outList[index]]; + + _Translator.push(luaState, outArg ); + + LuaTable outArgLuaBase = outArg as LuaTable; + if( outArgLuaBase != null && outArgLuaBase.IsOrphaned ) + { + outArgLuaBase.Dispose(); + } + } + + //by isSingle 2010-09-10 11:26:31 + //Desc: + // if not return void,we need add 1, + // or we will lost the function's return value + // when call dotnet function like "int foo(arg1,out arg2,out arg3)" in lua code + if (!_LastCalledMethod.IsReturnVoid && nReturnValues > 0) + { + nReturnValues++; + } + + return nReturnValues < 1 ? 1 : nReturnValues; + } + } + + + + + /// + /// We keep track of what delegates we have auto attached to an event - to allow us to cleanly exit a LuaInterface session + /// + class EventHandlerContainer : IDisposable + { + Dictionary dict = new Dictionary(); + + public void Add(Delegate handler, RegisterEventHandler eventInfo) + { + dict.Add(handler, eventInfo); + } + + public void Remove(Delegate handler) + { + bool found = dict.Remove(handler); + Debug.Assert(found); + } + + /// + /// Remove any still registered handlers + /// + public void Dispose() + { + foreach (KeyValuePair pair in dict) + { + pair.Value.RemovePending(pair.Key); + } + + dict.Clear(); + } + } + + + /* + * Wrapper class for events that does registration/deregistration + * of event handlers. + * + * Author: Fabio Mascarenhas + * Version: 1.0 + */ + class RegisterEventHandler + { + object target; + EventInfo eventInfo; + EventHandlerContainer pendingEvents; + + public RegisterEventHandler(EventHandlerContainer pendingEvents, object target, EventInfo eventInfo) + { + this.target = target; + this.eventInfo = eventInfo; + this.pendingEvents = pendingEvents; + } + + + /* + * Adds a new event handler + */ + public Delegate Add(LuaFunction function) + { + //CP: Fix by Ben Bryant for event handling with one parameter + //link: http://luaforge.net/forum/message.php?msg_id=9266 + Delegate handlerDelegate = CodeGeneration.Instance.GetDelegate(eventInfo.EventHandlerType, function); + eventInfo.AddEventHandler(target, handlerDelegate); + pendingEvents.Add(handlerDelegate, this); + + return handlerDelegate; + + + //MethodInfo mi = eventInfo.EventHandlerType.GetMethod("Invoke"); + //ParameterInfo[] pi = mi.GetParameters(); + //LuaEventHandler handler=CodeGeneration.Instance.GetEvent(pi[1].ParameterType,function); + + //Delegate handlerDelegate=Delegate.CreateDelegate(eventInfo.EventHandlerType,handler,"HandleEvent"); + //eventInfo.AddEventHandler(target,handlerDelegate); + //pendingEvents.Add(handlerDelegate, this); + + //return handlerDelegate; + } + + /* + * Removes an existing event handler + */ + public void Remove(Delegate handlerDelegate) + { + RemovePending(handlerDelegate); + pendingEvents.Remove(handlerDelegate); + } + + /* + * Removes an existing event handler (without updating the pending handlers list) + */ + internal void RemovePending(Delegate handlerDelegate) + { + eventInfo.RemoveEventHandler(target, handlerDelegate); + } + } + + /* + * Base wrapper class for Lua function event handlers. + * Subclasses that do actual event handling are created + * at runtime. + * + * Author: Fabio Mascarenhas + * Version: 1.0 + */ + public class LuaEventHandler + { + public LuaFunction handler = null; + + // CP: Fix provided by Ben Bryant for delegates with one param + // link: http://luaforge.net/forum/message.php?msg_id=9318 + public void handleEvent(object[] args) + { + handler.Call(args); + } + //public void handleEvent(object sender,object data) + //{ + // handler.call(new object[] { sender,data },new Type[0]); + //} + } + + /* + * Wrapper class for Lua functions as delegates + * Subclasses with correct signatures are created + * at runtime. + * + * Author: Fabio Mascarenhas + * Version: 1.0 + */ + public class LuaDelegate + { + public Type[] returnTypes; + public LuaFunction function; + public LuaDelegate() + { + function = null; + returnTypes = null; + } + public object callFunction(object[] args, object[] inArgs, int[] outArgs) + { + // args is the return array of arguments, inArgs is the actual array + // of arguments passed to the function (with in parameters only), outArgs + // has the positions of out parameters + object returnValue; + int iRefArgs; + object[] returnValues = function.call(inArgs, returnTypes); + if (returnTypes[0] == typeof(void)) + { + returnValue = null; + iRefArgs = 0; + } + else + { + returnValue = returnValues[0]; + iRefArgs = 1; + } + // Sets the value of out and ref parameters (from + // the values returned by the Lua function). + for (int i = 0; i < outArgs.Length; i++) + { + args[outArgs[i]] = returnValues[iRefArgs]; + iRefArgs++; + } + return returnValue; + } + } + + /* + * Static helper methods for Lua tables acting as CLR objects. + * + * Author: Fabio Mascarenhas + * Version: 1.0 + */ + public class LuaClassHelper + { + /* + * Gets the function called name from the provided table, + * returning null if it does not exist + */ + public static LuaFunction getTableFunction(LuaTable luaTable, string name) + { + object funcObj = luaTable.rawget(name); + if (funcObj is LuaFunction) + return (LuaFunction)funcObj; + else + return null; + } + /* + * Calls the provided function with the provided parameters + */ + public static object callFunction(LuaFunction function, object[] args, Type[] returnTypes, object[] inArgs, int[] outArgs) + { + // args is the return array of arguments, inArgs is the actual array + // of arguments passed to the function (with in parameters only), outArgs + // has the positions of out parameters + object returnValue; + int iRefArgs; + object[] returnValues = function.call(inArgs, returnTypes); + if (returnTypes[0] == typeof(void)) + { + returnValue = null; + iRefArgs = 0; + } + else + { + returnValue = returnValues[0]; + iRefArgs = 1; + } + for (int i = 0; i < outArgs.Length; i++) + { + args[outArgs[i]] = returnValues[iRefArgs]; + iRefArgs++; + } + return returnValue; + } + } +} diff --git a/LuaInterface/ObjectTranslator.cs b/LuaInterface/ObjectTranslator.cs new file mode 100644 index 0000000000..a28c73e236 --- /dev/null +++ b/LuaInterface/ObjectTranslator.cs @@ -0,0 +1,870 @@ +namespace LuaInterface +{ + using System; + using System.IO; + using System.Collections; + using System.Reflection; + using System.Collections.Generic; + using System.Diagnostics; + + /* + * Passes objects from the CLR to Lua and vice-versa + * + * Author: Fabio Mascarenhas + * Version: 1.0 + */ + public class ObjectTranslator + { + internal CheckType typeChecker; + + // object # to object (FIXME - it should be possible to get object address as an object #) + public readonly Dictionary objects = new Dictionary(); + // object to object # + public readonly Dictionary objectsBackMap = new Dictionary(); + internal Lua interpreter; + private MetaFunctions metaFunctions; + private List assemblies; + private LuaCSFunction getMethodSigFunction, getConstructorSigFunction, ctypeFunction, enumFromIntFunction; + + internal EventHandlerContainer pendingEvents = new EventHandlerContainer(); + + public ObjectTranslator(Lua interpreter,IntPtr luaState) + { + this.interpreter = interpreter; + typeChecker = new CheckType(this); + metaFunctions = new MetaFunctions(this); + assemblies = new List(); + + getMethodSigFunction= getMethodSignature; + getConstructorSigFunction= getConstructorSignature; + + ctypeFunction = ctype; + enumFromIntFunction = enumFromInt; + + createLuaObjectList(luaState); + createIndexingMetaFunction(luaState); + createBaseClassMetatable(luaState); + createClassMetatable(luaState); + createFunctionMetatable(luaState); + setGlobalFunctions(luaState); + } + + /* + * Sets up the list of objects in the Lua side + */ + private void createLuaObjectList(IntPtr luaState) + { + LuaDLL.lua_pushstring(luaState,"luaNet_objects"); + LuaDLL.lua_newtable(luaState); + LuaDLL.lua_newtable(luaState); + LuaDLL.lua_pushstring(luaState,"__mode"); + LuaDLL.lua_pushstring(luaState,"v"); + LuaDLL.lua_settable(luaState,-3); + LuaDLL.lua_setmetatable(luaState,-2); + LuaDLL.lua_settable(luaState, (int) LuaIndexes.LUA_REGISTRYINDEX); + } + /* + * Registers the indexing function of CLR objects + * passed to Lua + */ + private void createIndexingMetaFunction(IntPtr luaState) + { + LuaDLL.lua_pushstring(luaState,"luaNet_indexfunction"); + LuaDLL.luaL_dostring(luaState,MetaFunctions.luaIndexFunction); // steffenj: lua_dostring renamed to luaL_dostring + //LuaDLL.lua_pushstdcallcfunction(luaState,indexFunction); + LuaDLL.lua_rawset(luaState, (int) LuaIndexes.LUA_REGISTRYINDEX); + } + /* + * Creates the metatable for superclasses (the base + * field of registered tables) + */ + private void createBaseClassMetatable(IntPtr luaState) + { + LuaDLL.luaL_newmetatable(luaState,"luaNet_searchbase"); + LuaDLL.lua_pushstring(luaState,"__gc"); + LuaDLL.lua_pushstdcallcfunction(luaState,metaFunctions.gcFunction); + LuaDLL.lua_settable(luaState,-3); + LuaDLL.lua_pushstring(luaState,"__tostring"); + LuaDLL.lua_pushstdcallcfunction(luaState,metaFunctions.toStringFunction); + LuaDLL.lua_settable(luaState,-3); + LuaDLL.lua_pushstring(luaState,"__index"); + LuaDLL.lua_pushstdcallcfunction(luaState,metaFunctions.baseIndexFunction); + LuaDLL.lua_settable(luaState,-3); + LuaDLL.lua_pushstring(luaState,"__newindex"); + LuaDLL.lua_pushstdcallcfunction(luaState,metaFunctions.newindexFunction); + LuaDLL.lua_settable(luaState,-3); + LuaDLL.lua_settop(luaState,-2); + } + /* + * Creates the metatable for type references + */ + private void createClassMetatable(IntPtr luaState) + { + LuaDLL.luaL_newmetatable(luaState,"luaNet_class"); + LuaDLL.lua_pushstring(luaState,"__gc"); + LuaDLL.lua_pushstdcallcfunction(luaState,metaFunctions.gcFunction); + LuaDLL.lua_settable(luaState,-3); + LuaDLL.lua_pushstring(luaState,"__tostring"); + LuaDLL.lua_pushstdcallcfunction(luaState,metaFunctions.toStringFunction); + LuaDLL.lua_settable(luaState,-3); + LuaDLL.lua_pushstring(luaState,"__index"); + LuaDLL.lua_pushstdcallcfunction(luaState,metaFunctions.classIndexFunction); + LuaDLL.lua_settable(luaState,-3); + LuaDLL.lua_pushstring(luaState,"__newindex"); + LuaDLL.lua_pushstdcallcfunction(luaState,metaFunctions.classNewindexFunction); + LuaDLL.lua_settable(luaState,-3); + LuaDLL.lua_pushstring(luaState,"__call"); + LuaDLL.lua_pushstdcallcfunction(luaState,metaFunctions.callConstructorFunction); + LuaDLL.lua_settable(luaState,-3); + LuaDLL.lua_settop(luaState,-2); + } + /* + * Registers the global functions used by LuaInterface + */ + private void setGlobalFunctions(IntPtr luaState) + { + LuaDLL.lua_pushstdcallcfunction(luaState,metaFunctions.indexFunction); + LuaDLL.lua_setglobal(luaState,"get_object_member"); + /*LuaDLL.lua_pushstdcallcfunction(luaState,importTypeFunction); + LuaDLL.lua_setglobal(luaState,"import_type"); + LuaDLL.lua_pushstdcallcfunction(luaState,loadAssemblyFunction); + LuaDLL.lua_setglobal(luaState,"load_assembly"); + LuaDLL.lua_pushstdcallcfunction(luaState,registerTableFunction); + LuaDLL.lua_setglobal(luaState,"make_object"); + LuaDLL.lua_pushstdcallcfunction(luaState,unregisterTableFunction); + LuaDLL.lua_setglobal(luaState,"free_object");*/ + LuaDLL.lua_pushstdcallcfunction(luaState,getMethodSigFunction); + LuaDLL.lua_setglobal(luaState,"get_method_bysig"); + LuaDLL.lua_pushstdcallcfunction(luaState,getConstructorSigFunction); + LuaDLL.lua_setglobal(luaState,"get_constructor_bysig"); + LuaDLL.lua_pushstdcallcfunction(luaState,ctypeFunction); + LuaDLL.lua_setglobal(luaState,"ctype"); + LuaDLL.lua_pushstdcallcfunction(luaState,enumFromIntFunction); + LuaDLL.lua_setglobal(luaState,"enum"); + + } + + /* + * Creates the metatable for delegates + */ + private void createFunctionMetatable(IntPtr luaState) + { + LuaDLL.luaL_newmetatable(luaState,"luaNet_function"); + LuaDLL.lua_pushstring(luaState,"__gc"); + LuaDLL.lua_pushstdcallcfunction(luaState,metaFunctions.gcFunction); + LuaDLL.lua_settable(luaState,-3); + LuaDLL.lua_pushstring(luaState,"__call"); + LuaDLL.lua_pushstdcallcfunction(luaState,metaFunctions.execDelegateFunction); + LuaDLL.lua_settable(luaState,-3); + LuaDLL.lua_settop(luaState,-2); + } + /* + * Passes errors (argument e) to the Lua interpreter + */ + internal void throwError(IntPtr luaState, object e) + { + // We use this to remove anything pushed by luaL_where + int oldTop = LuaDLL.lua_gettop(luaState); + + // Stack frame #1 is our C# wrapper, so not very interesting to the user + // Stack frame #2 must be the lua code that called us, so that's what we want to use + LuaDLL.luaL_where(luaState, 1); + object[] curlev = popValues(luaState, oldTop); + + // Determine the position in the script where the exception was triggered + string errLocation = ""; + if (curlev.Length > 0) + errLocation = curlev[0].ToString(); + + string message = e as string; + if (message != null) + { + // Wrap Lua error (just a string) and store the error location + e = new LuaScriptException(message, errLocation); + } + else + { + Exception ex = e as Exception; + if (ex != null) + { + // Wrap generic .NET exception as an InnerException and store the error location + e = new LuaScriptException(ex, errLocation); + } + } + + push(luaState, e); + LuaDLL.lua_error(luaState); + } + /* + * Implementation of load_assembly. Throws an error + * if the assembly is not found. + */ + private int loadAssembly(IntPtr luaState) + { + try + { + string assemblyName = LuaDLL.lua_tostring(luaState,1); + + Assembly assembly = Assembly.Load(AssemblyName.GetAssemblyName(assemblyName)); + + if (assembly != null && !assemblies.Contains(assembly)) + { + assemblies.Add(assembly); + } + } + catch(Exception e) + { + throwError(luaState,e); + } + + return 0; + } + + internal Type FindType(string className) + { + foreach(Assembly assembly in assemblies) + { + Type klass=assembly.GetType(className); + if(klass!=null) + { + return klass; + } + } + return null; + } + + /* + * Implementation of import_type. Returns nil if the + * type is not found. + */ + private int importType(IntPtr luaState) + { + string className=LuaDLL.lua_tostring(luaState,1); + Type klass=FindType(className); + if(klass!=null) + pushType(luaState,klass); + else + LuaDLL.lua_pushnil(luaState); + return 1; + } + /* + * Implementation of make_object. Registers a table (first + * argument in the stack) as an object subclassing the + * type passed as second argument in the stack. + */ + private int registerTable(IntPtr luaState) + { + if(LuaDLL.lua_type(luaState,1)==LuaTypes.LUA_TTABLE) + { + LuaTable luaTable=getTable(luaState,1); + string superclassName = LuaDLL.lua_tostring(luaState, 2); + if (superclassName != null) + { + Type klass = FindType(superclassName); + if (klass != null) + { + // Creates and pushes the object in the stack, setting + // it as the metatable of the first argument + object obj = CodeGeneration.Instance.GetClassInstance(klass, luaTable); + pushObject(luaState, obj, "luaNet_metatable"); + LuaDLL.lua_newtable(luaState); + LuaDLL.lua_pushstring(luaState, "__index"); + LuaDLL.lua_pushvalue(luaState, -3); + LuaDLL.lua_settable(luaState, -3); + LuaDLL.lua_pushstring(luaState, "__newindex"); + LuaDLL.lua_pushvalue(luaState, -3); + LuaDLL.lua_settable(luaState, -3); + LuaDLL.lua_setmetatable(luaState, 1); + // Pushes the object again, this time as the base field + // of the table and with the luaNet_searchbase metatable + LuaDLL.lua_pushstring(luaState, "base"); + int index = addObject(obj); + pushNewObject(luaState, obj, index, "luaNet_searchbase"); + LuaDLL.lua_rawset(luaState, 1); + } + else + throwError(luaState, "register_table: can not find superclass '" + superclassName + "'"); + } + else + throwError(luaState, "register_table: superclass name can not be null"); + } + else throwError(luaState,"register_table: first arg is not a table"); + return 0; + } + /* + * Implementation of free_object. Clears the metatable and the + * base field, freeing the created object for garbage-collection + */ + private int unregisterTable(IntPtr luaState) + { + try + { + if(LuaDLL.lua_getmetatable(luaState,1)!=0) + { + LuaDLL.lua_pushstring(luaState,"__index"); + LuaDLL.lua_gettable(luaState,-2); + object obj=getRawNetObject(luaState,-1); + if(obj==null) throwError(luaState,"unregister_table: arg is not valid table"); + FieldInfo luaTableField=obj.GetType().GetField("__luaInterface_luaTable"); + if(luaTableField==null) throwError(luaState,"unregister_table: arg is not valid table"); + luaTableField.SetValue(obj,null); + LuaDLL.lua_pushnil(luaState); + LuaDLL.lua_setmetatable(luaState,1); + LuaDLL.lua_pushstring(luaState,"base"); + LuaDLL.lua_pushnil(luaState); + LuaDLL.lua_settable(luaState,1); + } + else throwError(luaState,"unregister_table: arg is not valid table"); + } + catch(Exception e) + { + throwError(luaState,e.Message); + } + return 0; + } + /* + * Implementation of get_method_bysig. Returns nil + * if no matching method is not found. + */ + private int getMethodSignature(IntPtr luaState) + { + IReflect klass; object target; + int udata=LuaDLL.luanet_checkudata(luaState,1,"luaNet_class"); + if(udata!=-1) + { + klass=(IReflect)objects[udata]; + target=null; + } + else + { + target=getRawNetObject(luaState,1); + if(target==null) + { + throwError(luaState,"get_method_bysig: first arg is not type or object reference"); + LuaDLL.lua_pushnil(luaState); + return 1; + } + klass=target.GetType(); + } + string methodName=LuaDLL.lua_tostring(luaState,2); + Type[] signature=new Type[LuaDLL.lua_gettop(luaState)-2]; + for(int i=0;i + /// Given the Lua int ID for an object remove it from our maps + /// + /// + internal void collectObject(int udata) + { + object o; + bool found = objects.TryGetValue(udata, out o); + + // The other variant of collectObject might have gotten here first, in that case we will silently ignore the missing entry + if (found) + { + // Debug.WriteLine("Removing " + o.ToString() + " @ " + udata); + + objects.Remove(udata); + objectsBackMap.Remove(o); + } + } + + + /// + /// Given an object reference, remove it from our maps + /// + /// + void collectObject(object o, int udata) + { + // Debug.WriteLine("Removing " + o.ToString() + " @ " + udata); + + objects.Remove(udata); + objectsBackMap.Remove(o); + } + + + /// + /// We want to ensure that objects always have a unique ID + /// + int nextObj = 0; + + int addObject(object obj) + { + // New object: inserts it in the list + int index = nextObj++; + + // Debug.WriteLine("Adding " + obj.ToString() + " @ " + index); + + objects[index] = obj; + objectsBackMap[obj] = index; + + return index; + } + + + + /* + * Gets an object from the Lua stack according to its Lua type. + */ + internal object getObject(IntPtr luaState,int index) + { + LuaTypes type=LuaDLL.lua_type(luaState,index); + switch(type) + { + case LuaTypes.LUA_TNUMBER: + { + return LuaDLL.lua_tonumber(luaState,index); + } + case LuaTypes.LUA_TSTRING: + { + return LuaDLL.lua_tostring(luaState,index); + } + case LuaTypes.LUA_TBOOLEAN: + { + return LuaDLL.lua_toboolean(luaState,index); + } + case LuaTypes.LUA_TTABLE: + { + return getTable(luaState,index); + } + case LuaTypes.LUA_TFUNCTION: + { + return getFunction(luaState,index); + } + case LuaTypes.LUA_TUSERDATA: + { + int udata=LuaDLL.luanet_tonetobject(luaState,index); + if(udata!=-1) + return objects[udata]; + else + return getUserData(luaState,index); + } + default: + return null; + } + } + /* + * Gets the table in the index positon of the Lua stack. + */ + internal LuaTable getTable(IntPtr luaState,int index) + { + LuaDLL.lua_pushvalue(luaState,index); + return new LuaTable(LuaDLL.lua_ref(luaState,1),interpreter); + } + /* + * Gets the userdata in the index positon of the Lua stack. + */ + internal LuaUserData getUserData(IntPtr luaState,int index) + { + LuaDLL.lua_pushvalue(luaState,index); + return new LuaUserData(LuaDLL.lua_ref(luaState,1),interpreter); + } + /* + * Gets the function in the index positon of the Lua stack. + */ + internal LuaFunction getFunction(IntPtr luaState,int index) + { + LuaDLL.lua_pushvalue(luaState,index); + return new LuaFunction(LuaDLL.lua_ref(luaState,1),interpreter); + } + /* + * Gets the CLR object in the index positon of the Lua stack. Returns + * delegates as Lua functions. + */ + internal object getNetObject(IntPtr luaState,int index) + { + int idx=LuaDLL.luanet_tonetobject(luaState,index); + if(idx!=-1) + return objects[idx]; + else + return null; + } + /* + * Gets the CLR object in the index positon of the Lua stack. Returns + * delegates as is. + */ + internal object getRawNetObject(IntPtr luaState,int index) + { + int udata=LuaDLL.luanet_rawnetobj(luaState,index); + if(udata!=-1) + { + return objects[udata]; + } + return null; + } + /* + * Pushes the entire array into the Lua stack and returns the number + * of elements pushed. + */ + internal int returnValues(IntPtr luaState, object[] returnValues) + { + if(LuaDLL.lua_checkstack(luaState,returnValues.Length+5)) + { + for(int i=0;i + /// Summary description for ProxyType. + /// + public class ProxyType : IReflect + { + + Type proxy; + + public ProxyType(Type proxy) + { + this.proxy = proxy; + } + + /// + /// Provide human readable short hand for this proxy object + /// + /// + public override string ToString() + { + return "ProxyType(" + UnderlyingSystemType + ")"; + } + + + public Type UnderlyingSystemType + { + get + { + return proxy; + } + } + + public FieldInfo GetField(string name, BindingFlags bindingAttr) + { + return proxy.GetField(name, bindingAttr); + } + + public FieldInfo[] GetFields(BindingFlags bindingAttr) + { + return proxy.GetFields(bindingAttr); + } + + public MemberInfo[] GetMember(string name, BindingFlags bindingAttr) + { + return proxy.GetMember(name, bindingAttr); + } + + public MemberInfo[] GetMembers(BindingFlags bindingAttr) + { + return proxy.GetMembers(bindingAttr); + } + + public MethodInfo GetMethod(string name, BindingFlags bindingAttr) + { + return proxy.GetMethod(name, bindingAttr); + } + + public MethodInfo GetMethod(string name, BindingFlags bindingAttr, Binder binder, Type[] types, ParameterModifier[] modifiers) + { + return proxy.GetMethod(name, bindingAttr, binder, types, modifiers); + } + + public MethodInfo[] GetMethods(BindingFlags bindingAttr) + { + return proxy.GetMethods(bindingAttr); + } + + public PropertyInfo GetProperty(string name, BindingFlags bindingAttr) + { + return proxy.GetProperty(name, bindingAttr); + } + + public PropertyInfo GetProperty(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers) + { + return proxy.GetProperty(name, bindingAttr, binder, returnType, types, modifiers); + } + + public PropertyInfo[] GetProperties(BindingFlags bindingAttr) + { + return proxy.GetProperties(bindingAttr); + } + + public object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters) + { + return proxy.InvokeMember(name, invokeAttr, binder, target, args, modifiers, culture, namedParameters); + } + + } +} diff --git a/OpenRA.sln b/OpenRA.sln index 2e9cbc466c..b343c4d9ec 100644 --- a/OpenRA.sln +++ b/OpenRA.sln @@ -41,6 +41,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenRA.Irc", "OpenRA.Irc\Op EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenRA.Renderer.Sdl2", "OpenRA.Renderer.Sdl2\OpenRA.Renderer.Sdl2.csproj", "{33D03738-C154-4028-8EA8-63A3C488A651}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LuaInterface", "LuaInterface\LuaInterface.csproj", "{E915A0A4-2641-4F7E-8A88-8F123FA88BF1}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -184,6 +186,14 @@ Global {85B48234-8B31-4BE6-AF9C-665CC6866841}.Release|Any CPU.Build.0 = Release|Any CPU {85B48234-8B31-4BE6-AF9C-665CC6866841}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU {85B48234-8B31-4BE6-AF9C-665CC6866841}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {E915A0A4-2641-4F7E-8A88-8F123FA88BF1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E915A0A4-2641-4F7E-8A88-8F123FA88BF1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E915A0A4-2641-4F7E-8A88-8F123FA88BF1}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {E915A0A4-2641-4F7E-8A88-8F123FA88BF1}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {E915A0A4-2641-4F7E-8A88-8F123FA88BF1}.Release|Any CPU.ActiveCfg = Debug|Any CPU + {E915A0A4-2641-4F7E-8A88-8F123FA88BF1}.Release|Any CPU.Build.0 = Debug|Any CPU + {E915A0A4-2641-4F7E-8A88-8F123FA88BF1}.Release|Mixed Platforms.ActiveCfg = Debug|Any CPU + {E915A0A4-2641-4F7E-8A88-8F123FA88BF1}.Release|Mixed Platforms.Build.0 = Debug|Any CPU EndGlobalSection GlobalSection(MonoDevelopProperties) = preSolution StartupItem = OpenRA.Game\OpenRA.Game.csproj From b2f46a56ea908c81a60377a7d59306a5ece08298 Mon Sep 17 00:00:00 2001 From: ScottNZ Date: Fri, 15 Nov 2013 21:56:23 +1300 Subject: [PATCH 03/18] Add FindType method to ObjectCreator --- OpenRA.Game/ObjectCreator.cs | 46 +++++++++++++++++++++--------------- 1 file changed, 27 insertions(+), 19 deletions(-) diff --git a/OpenRA.Game/ObjectCreator.cs b/OpenRA.Game/ObjectCreator.cs index e7a54ab96a..cdf01b0a21 100755 --- a/OpenRA.Game/ObjectCreator.cs +++ b/OpenRA.Game/ObjectCreator.cs @@ -19,13 +19,15 @@ namespace OpenRA { public class ObjectCreator { - Pair[] modAssemblies; + Pair[] assemblies; public ObjectCreator(Manifest manifest) { // All the core namespaces - var asms = typeof(Game).Assembly.GetNamespaces() + var asms = typeof(Game).Assembly.GetNamespaces() // Game .Select(c => Pair.New(typeof(Game).Assembly, c)) + .Concat(typeof(Mod).Assembly.GetNamespaces() // FileFormats + .Select(c => Pair.New(typeof(Mod).Assembly, c))) .ToList(); // Namespaces from each mod assembly @@ -35,7 +37,7 @@ namespace OpenRA asms.AddRange(asm.GetNamespaces().Select(ns => Pair.New(asm, ns))); } - modAssemblies = asms.ToArray(); + assemblies = asms.ToArray(); } public static Action MissingTypeAction = @@ -48,24 +50,30 @@ namespace OpenRA public T CreateObject(string className, Dictionary args) { - foreach (var mod in modAssemblies) + var type = FindType(className); + if (type == null) { - var type = mod.First.GetType(mod.Second + "." + className, false); - if (type == null) continue; - var flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance; - var ctors = type.GetConstructors(flags) - .Where(x => x.HasAttribute()).ToList(); - - if (ctors.Count == 0) - return (T)CreateBasic(type); - else if (ctors.Count == 1) - return (T)CreateUsingArgs(ctors[0], args); - else - throw new InvalidOperationException("ObjectCreator: UseCtor on multiple constructors; invalid."); + MissingTypeAction(className); + return default(T); } - MissingTypeAction(className); - return default(T); + var flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance; + var ctors = type.GetConstructors(flags) + .Where(x => x.HasAttribute()).ToList(); + + if (ctors.Count == 0) + return (T)CreateBasic(type); + else if (ctors.Count == 1) + return (T)CreateUsingArgs(ctors[0], args); + else + throw new InvalidOperationException("ObjectCreator: UseCtor on multiple constructors; invalid."); + } + + public Type FindType(string className) + { + return assemblies + .Select(pair => pair.First.GetType(pair.Second + "." + className, false)) + .FirstOrDefault(t => t != null); } public object CreateBasic(Type type) @@ -90,7 +98,7 @@ namespace OpenRA public IEnumerable GetTypesImplementing() { var it = typeof(T); - return modAssemblies.Select(ma => ma.First).Distinct() + return assemblies.Select(ma => ma.First).Distinct() .SelectMany(ma => ma.GetTypes() .Where(t => t != it && it.IsAssignableFrom(t))); } From cd0b3d886210f3c9fbcfbeec289ef42f257af13e Mon Sep 17 00:00:00 2001 From: ScottNZ Date: Fri, 15 Nov 2013 21:57:44 +1300 Subject: [PATCH 04/18] Add map scripting support --- OpenRA.FileFormats/Manifest.cs | 3 +- OpenRA.Game/Map.cs | 20 +-- OpenRA.Mods.RA/OpenRA.Mods.RA.csproj | 6 + OpenRA.Mods.RA/Scripting/LuaScriptContext.cs | 134 ++++++++++++++ .../Scripting/LuaScriptInterface.cs | 165 ++++++++++++++++++ 5 files changed, 317 insertions(+), 11 deletions(-) create mode 100644 OpenRA.Mods.RA/Scripting/LuaScriptContext.cs create mode 100644 OpenRA.Mods.RA/Scripting/LuaScriptInterface.cs diff --git a/OpenRA.FileFormats/Manifest.cs b/OpenRA.FileFormats/Manifest.cs index fbc8c0c9d1..22a6fdcf90 100644 --- a/OpenRA.FileFormats/Manifest.cs +++ b/OpenRA.FileFormats/Manifest.cs @@ -22,7 +22,7 @@ namespace OpenRA.FileFormats Folders, MapFolders, Rules, ServerTraits, Sequences, VoxelSequences, Cursors, Chrome, Assemblies, ChromeLayout, Weapons, Voices, Notifications, Music, Movies, Translations, TileSets, - ChromeMetrics, PackageContents; + ChromeMetrics, PackageContents, LuaScripts; public readonly Dictionary Packages; public readonly MiniYaml LoadScreen; @@ -59,6 +59,7 @@ namespace OpenRA.FileFormats TileSets = YamlList(yaml, "TileSets"); ChromeMetrics = YamlList(yaml, "ChromeMetrics"); PackageContents = YamlList(yaml, "PackageContents"); + LuaScripts = YamlList(yaml, "LuaScripts"); LoadScreen = yaml["LoadScreen"]; LobbyDefaults = yaml["LobbyDefaults"]; diff --git a/OpenRA.Game/Map.cs b/OpenRA.Game/Map.cs index fd28aec8c0..8399e50a34 100644 --- a/OpenRA.Game/Map.cs +++ b/OpenRA.Game/Map.cs @@ -54,7 +54,7 @@ namespace OpenRA public class Map { - [FieldLoader.Ignore] IFolder container; + [FieldLoader.Ignore] public IFolder Container; public string Path { get; private set; } // Yaml map data @@ -132,7 +132,7 @@ namespace OpenRA void AssertExists(string filename) { - using (var s = container.GetContent(filename)) + using (var s = Container.GetContent(filename)) if (s == null) throw new InvalidOperationException("Required file {0} not present in this map".F(filename)); } @@ -142,12 +142,12 @@ namespace OpenRA public Map(string path) { Path = path; - container = FileSystem.OpenPackage(path, null, int.MaxValue); + Container = FileSystem.OpenPackage(path, null, int.MaxValue); AssertExists("map.yaml"); AssertExists("map.bin"); - var yaml = new MiniYaml(null, MiniYaml.FromStream(container.GetContent("map.yaml"))); + var yaml = new MiniYaml(null, MiniYaml.FromStream(Container.GetContent("map.yaml"))); FieldLoader.Load(this, yaml); Uid = ComputeHash(); @@ -263,17 +263,17 @@ namespace OpenRA // Create a new map package // TODO: Add other files (custom assets) to the entries list - container = FileSystem.CreatePackage(Path, int.MaxValue, entries); + Container = FileSystem.CreatePackage(Path, int.MaxValue, entries); } // Update existing package - container.Write(entries); + Container.Write(entries); } public TileReference[,] LoadMapTiles() { var tiles = new TileReference[MapSize.X, MapSize.Y]; - using (var dataStream = container.GetContent("map.bin")) + using (var dataStream = Container.GetContent("map.bin")) { if (dataStream.ReadUInt8() != 1) throw new InvalidDataException("Unknown binary map format"); @@ -305,7 +305,7 @@ namespace OpenRA { var resources = new TileReference[MapSize.X, MapSize.Y]; - using (var dataStream = container.GetContent("map.bin")) + using (var dataStream = Container.GetContent("map.bin")) { if (dataStream.ReadUInt8() != 1) throw new InvalidDataException("Unknown binary map format"); @@ -391,8 +391,8 @@ namespace OpenRA { // UID is calculated by taking an SHA1 of the yaml and binary data // Read the relevant data into a buffer - var data = container.GetContent("map.yaml").ReadAllBytes() - .Concat(container.GetContent("map.bin").ReadAllBytes()).ToArray(); + var data = Container.GetContent("map.yaml").ReadAllBytes() + .Concat(Container.GetContent("map.bin").ReadAllBytes()).ToArray(); // Take the SHA1 using (var csp = SHA1.Create()) diff --git a/OpenRA.Mods.RA/OpenRA.Mods.RA.csproj b/OpenRA.Mods.RA/OpenRA.Mods.RA.csproj index 50fdbc7c7e..0ae49ce679 100644 --- a/OpenRA.Mods.RA/OpenRA.Mods.RA.csproj +++ b/OpenRA.Mods.RA/OpenRA.Mods.RA.csproj @@ -338,8 +338,10 @@ + + @@ -476,6 +478,10 @@ + + {e915a0a4-2641-4f7e-8a88-8f123fa88bf1} + LuaInterface + {BDAEAB25-991E-46A7-AF1E-4F0E03358DAA} OpenRA.FileFormats diff --git a/OpenRA.Mods.RA/Scripting/LuaScriptContext.cs b/OpenRA.Mods.RA/Scripting/LuaScriptContext.cs new file mode 100644 index 0000000000..97fca80e64 --- /dev/null +++ b/OpenRA.Mods.RA/Scripting/LuaScriptContext.cs @@ -0,0 +1,134 @@ +#region Copyright & License Information +/* + * Copyright 2007-2013 The OpenRA Developers (see AUTHORS) + * This file is part of OpenRA, which is free software. It is made + * available to you under the terms of the GNU General Public License + * as published by the Free Software Foundation. For more information, + * see COPYING. + */ +#endregion + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using LuaInterface; + +namespace OpenRA.Mods.RA.Scripting +{ + public class LuaScriptContext : IDisposable + { + public Lua Lua { get; private set; } + + public LuaScriptContext() + { + Log.Write("debug", "Creating Lua script context"); + Lua = new Lua(); + } + + public void RegisterObject(object target, string tableName, bool exposeAllMethods) + { + Log.Write("debug", "Registering object {0}", target); + + if (tableName != null && Lua.GetTable(tableName) == null) + Lua.NewTable(tableName); + + var type = target.GetType(); + + var methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance); + RegisterMethods(tableName, target, methods, exposeAllMethods); + } + + public void RegisterType(Type type, string tableName, bool exposeAllMethods) + { + Log.Write("debug", "Registering type {0}", type); + + if (tableName != null && Lua.GetTable(tableName) == null) + Lua.NewTable(tableName); + + var methods = type.GetMethods(BindingFlags.Public | BindingFlags.Static); + RegisterMethods(tableName, null, methods, exposeAllMethods); + } + + void RegisterMethods(string tableName, object target, IEnumerable methods, bool allMethods) + { + foreach (var method in methods) + { + string methodName; + + var attr = method.GetCustomAttributes(true).FirstOrDefault(); + if (attr == null) + { + if (allMethods) + methodName = method.Name; + else + continue; + } + else + methodName = attr.Name ?? method.Name; + + var methodTarget = method.IsStatic ? null : target; + + if (tableName != null) + Lua.RegisterFunction(tableName + "." + methodName, methodTarget, method); + else + Lua.RegisterFunction(methodName, methodTarget, method); + } + } + + void LogException(Exception e) + { + Game.Debug("{0}", e.Message); + Game.Debug("See debug.log for details"); + Log.Write("debug", "{0}", e); + } + + public void LoadLuaScripts(Func getFileContents, params string[] files) + { + foreach (var file in files) + { + try + { + Log.Write("debug", "Loading Lua script {0}", file); + var content = getFileContents(file); + Lua.DoString(content, file); + } + catch (Exception e) + { + LogException(e); + } + } + } + + public object[] InvokeLuaFunction(string name, params object[] args) + { + try + { + var function = Lua.GetFunction(name); + if (function == null) + return null; + return function.Call(args); + } + catch (Exception e) + { + LogException(e); + return null; + } + } + + public void Dispose() + { + if (Lua == null) + return; + + GC.SuppressFinalize(this); + Lua.Dispose(); + Lua = null; + } + + ~LuaScriptContext() + { + Dispose(); + } + } +} diff --git a/OpenRA.Mods.RA/Scripting/LuaScriptInterface.cs b/OpenRA.Mods.RA/Scripting/LuaScriptInterface.cs new file mode 100644 index 0000000000..43f449bb9d --- /dev/null +++ b/OpenRA.Mods.RA/Scripting/LuaScriptInterface.cs @@ -0,0 +1,165 @@ +#region Copyright & License Information +/* + * Copyright 2007-2013 The OpenRA Developers (see AUTHORS) + * This file is part of OpenRA, which is free software. It is made + * available to you under the terms of the GNU General Public License + * as published by the Free Software Foundation. For more information, + * see COPYING. + */ +#endregion + +using System; +using System.Linq; +using LuaInterface; +using OpenRA.Effects; +using OpenRA.FileFormats; +using OpenRA.Traits; +using WorldRenderer = OpenRA.Graphics.WorldRenderer; + +namespace OpenRA.Mods.RA.Scripting +{ + public class LuaScriptInterfaceInfo : ITraitInfo, Requires + { + public readonly string[] LuaScripts = { }; + + public object Create(ActorInitializer init) { return new LuaScriptInterface(this); } + } + + public class LuaScriptInterface : IWorldLoaded, ITick + { + World world; + readonly LuaScriptContext context = new LuaScriptContext(); + readonly LuaScriptInterfaceInfo info; + + public LuaScriptInterface(LuaScriptInterfaceInfo info) + { + this.info = info; + } + + public void WorldLoaded(World w, WorldRenderer wr) + { + world = w; + AddMapActorGlobals(); + context.Lua["World"] = w; + context.Lua["WorldRenderer"] = wr; + context.RegisterObject(this, "_OpenRA", false); + context.RegisterType(typeof(WVec), "WVec", true); + context.RegisterType(typeof(WPos), "WPos", true); + context.RegisterType(typeof(CPos), "CPos", true); + context.RegisterType(typeof(WRot), "WRot", true); + context.RegisterType(typeof(WAngle), "WAngle", true); + context.RegisterType(typeof(WRange), "WRange", true); + context.RegisterType(typeof(int2), "int2", true); + context.RegisterType(typeof(float2), "float2", true); + var sharedScripts = Game.modData.Manifest.LuaScripts ?? new string[0]; + if (sharedScripts.Any()) + context.LoadLuaScripts(f => FileSystem.Open(f).ReadAllText(), sharedScripts); + context.LoadLuaScripts(f => w.Map.Container.GetContent(f).ReadAllText(), info.LuaScripts); + context.InvokeLuaFunction("WorldLoaded"); + } + + void AddMapActorGlobals() + { + foreach (var kv in world.WorldActor.Trait().Actors) + context.Lua[kv.Key] = kv.Value; + } + + public void Tick(Actor self) + { + context.InvokeLuaFunction("Tick"); + } + + [LuaGlobal] + public object New(string typeName, LuaTable args) + { + var type = Game.modData.ObjectCreator.FindType(typeName); + if (type == null) + throw new InvalidOperationException("Cannot locate type: {0}".F(typeName)); + if (args == null) + return Activator.CreateInstance(type); + var argsArray = ConvertArgs(args); + return Activator.CreateInstance(type, argsArray); + } + + object[] ConvertArgs(LuaTable args) + { + var argsArray = new object[args.Keys.Count]; + for (var i = 1; i <= args.Keys.Count; i++) + { + var arg = args[i] as LuaTable; + if (arg != null && arg[1] != null && arg[2] != null) + argsArray[i - 1] = Convert.ChangeType(arg[1], Enum.Parse(arg[2].ToString())); + else + argsArray[i - 1] = args[i]; + } + return argsArray; + } + + [LuaGlobal] + public void Debug(object obj) + { + if (obj != null) + Game.Debug(obj.ToString()); + } + + [LuaGlobal] + public object TraitOrDefault(Actor actor, string className) + { + var type = Game.modData.ObjectCreator.FindType(className); + if (type == null) + return null; + + var method = typeof(Actor).GetMethod("TraitOrDefault"); + var genericMethod = method.MakeGenericMethod(type); + return genericMethod.Invoke(actor, null); + } + + [LuaGlobal] + public object Trait(Actor actor, string className) + { + var ret = TraitOrDefault(actor, className); + if (ret == null) + throw new InvalidOperationException("Actor {0} does not have trait of type {1}".F(actor, className)); + return ret; + } + + [LuaGlobal] + public bool HasTrait(Actor actor, string className) + { + var ret = TraitOrDefault(actor, className); + return ret != null; + } + + [LuaGlobal] + public object TraitInfoOrDefault(string actorType, string className) + { + var type = Game.modData.ObjectCreator.FindType(className); + if (type == null || !Rules.Info.ContainsKey(actorType)) + return null; + + return Rules.Info[actorType].Traits.GetOrDefault(type); + } + + [LuaGlobal] + public object TraitInfo(string actorType, string className) + { + var ret = TraitInfoOrDefault(actorType, className); + if (ret == null) + throw new InvalidOperationException("Actor type {0} does not have trait info of type {1}".F(actorType, className)); + return ret; + } + + [LuaGlobal] + public bool HasTraitInfo(string actorType, string className) + { + var ret = TraitInfoOrDefault(actorType, className); + return ret != null; + } + + [LuaGlobal] + public void RunAfterDelay(double delay, Action func) + { + world.AddFrameEndTask(w => w.Add(new DelayedAction((int)delay, func))); + } + } +} From e730580030768f6220d7b59a749e9eb8b8fdd0cb Mon Sep 17 00:00:00 2001 From: ScottNZ Date: Fri, 15 Nov 2013 22:00:27 +1300 Subject: [PATCH 05/18] Add LuaInterface dependencies --- packaging/windows/lua51.dll | Bin 0 -> 166912 bytes thirdparty/LuaInterface.dll.config | 5 +++++ thirdparty/liblua-linux32.so | Bin 0 -> 202864 bytes thirdparty/liblua-linux64.so | Bin 0 -> 211359 bytes thirdparty/liblua-osx.dylib | Bin 0 -> 166232 bytes 5 files changed, 5 insertions(+) create mode 100644 packaging/windows/lua51.dll create mode 100644 thirdparty/LuaInterface.dll.config create mode 100644 thirdparty/liblua-linux32.so create mode 100644 thirdparty/liblua-linux64.so create mode 100644 thirdparty/liblua-osx.dylib diff --git a/packaging/windows/lua51.dll b/packaging/windows/lua51.dll new file mode 100644 index 0000000000000000000000000000000000000000..07f311f7038ecccd448dfdddcaeb083d74be5a9e GIT binary patch literal 166912 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 E1Fu%CZU6uP literal 0 HcmV?d00001 diff --git a/thirdparty/LuaInterface.dll.config b/thirdparty/LuaInterface.dll.config new file mode 100644 index 0000000000..97931b2a89 --- /dev/null +++ b/thirdparty/LuaInterface.dll.config @@ -0,0 +1,5 @@ + + + + + diff --git a/thirdparty/liblua-linux32.so b/thirdparty/liblua-linux32.so new file mode 100644 index 0000000000000000000000000000000000000000..fec86439950ca1a0621e10f9e20cb3834f2405e1 GIT binary patch literal 202864 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

@OUub)Z6y`H+VIJ6O%Xf{|0=J!Ch?i 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 literal 0 HcmV?d00001 diff --git a/thirdparty/liblua-linux64.so b/thirdparty/liblua-linux64.so new file mode 100644 index 0000000000000000000000000000000000000000..dfe43c611540c9ef3242492b804f430b225552db GIT binary patch literal 211359 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%0ALwb|z` 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 w(Y1A8U?!vFvP literal 0 HcmV?d00001 diff --git a/thirdparty/liblua-osx.dylib b/thirdparty/liblua-osx.dylib new file mode 100644 index 0000000000000000000000000000000000000000..01731e5f56f9b69bfa491226fdda66b1e0426f8d GIT binary patch literal 166232 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Ύ|r?+HDZ>jgm#;l|^x0cF=Z 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

dVTRJ+;3;aWUFo zO)wqhnjcy8ut~vnGf; z^iKrsm74Z0@fx?Vib<=Lw1AzRilroZ`vXKUKO2#vtzZ7a4^>%^BIl#^i_l9p6hJV; z%$UjfWN!ZjytE})6W3EY_x!QnVMSuHDamZhrLo;QCd;hDG2SoYwJZcoEF0`UuR0jn zC!j>jvw;vkq@6Qq$7YDXNi9x}yVJ{&xT6ckv9r$(<4?jYb_^T+)SVtL9KidWYZ#Xb z$1!0g2j8N$oDLzcMNfRn^q&>utV)Frb#PzyfmH!+Z8o}ji<(X5g(1 zF4fm-`TRkENj@t9ibc|}-I=|EfQIAFOMRg|`QohhZUe5;}C z|NJWGj`PYhE8Su@Q|Gs^r3>pE{gHL{Ike6TsMBltrd|nSs=m?os(vNyRWbgK;IDtIz3Rva zoRQ<#FdV`quZLM}wyqPpfA?t9sk4YInGyGXa5H{`9G<>=t$qb~8pXsw%C`bEE&ED= zh_L*XZUI0u2Rn?GF-O?*b}3f zZf`%`5dG|Y8$&-5{__uM<96J8w6WrlHlF*E`azrt{g@WE(b2n&b*KINxT-j$jfJKSjw+#z={Z^>d^h@w zwC0I~O>ThPWUhyW{|9pa?q|KxbQIOwI^5)j+)5c~#x}Z9xYvt&@GPF9_4G=rw>Us| zGywGN54wY)${{(F=dmgYR@jp3{fl@8;Lb#>-3<=s^H6FkxjK|SBPTzW6H9{p__tW8 z&mr)C4!>^>D|>{MFQ6o{ht)~0?}3$D%^=9lRD~kpw|Dl&%0Isl*5M}C7Z^e6<$}8P z5^je@MxWb3#>YZr_!sfh^dD7zy)$bVXL+wW0iVKyLSdGipi{#2F&2N7`MZiO^aj1t zQh!S~tdAsCz0Ghl2?=`Im$opJcas~*P~**hP4-McA2UKv8DY>m!2sjVBIm3bp#mHe z*Xtn@fAdqpX(=een#p?q=P}YBO}-}2){RPu;Wo7#$9x^#$F9TVhK`c4qQ5zPOz$El zX20GWh@YMM?*lRXa6r@p1j$Tsjws(Z4Czd%?CL0~R2MT^!Va7E3z`-N{ZsxIP5(ww zHiz_op0T&csGHn?K{915?T!^@*mn(^eGMl-9v+Q_YyqynX=j|n;Cj;G+VW@%OS8Lf zJ?AkpbL2Rh#HJhl@4in{$$h=Y`M==kKm8|f^qAyMr3G6@;W+<{*asZu#`#C^^=E!$ z_*#YGF@GsP4PO(5$G9GYFQ(Sn=}qm%4IejL%~CAfT-s5x8pOz@{${#iLuBcRqk{e2 zdd!mN`9sye<3XiU@^DRM!-mvrxvt~B-RQ4*kCqy?H+L6IXaAz#e_coMbFC?3x%iAL zOa)pF>Q)Q@$FalbUil+}%V-FPk!k1r2i+}G$z##xgTnp_?wVegIoBBh$);Qub)|O7 z@ABZVUUKYKGvE#@aV7}P9`teN7Et{~b^V9NyYb@xLXN$DNAFrcORX+mo#gtSa!iE$ zS8{B^4|~vi6+cbShZs4=iEfEiY^REJ2#FkB7Og+g*?|-1L8g&E8EtOH-dVO+EYXHnsS0O>Mzt&N_l^N{5!1G5s-kFUQzB z)a{4a+vX;B{4d7z5o)dn&s=QUQXT(a#`L8GG%{C(WBP7>8XA|IFf3!V;<-I zMU-T5zN2Kh7@(>$xk2=0fPYfy`k2)WeKGkr`jhBrIJh%vfT42Q6cZnipYm_LQ1bGy zLuJryy}SMS%LFMTCO_%BZq%ezOx_zFkTHMtQoJD^f48tDCdOX_f7nmqdCHuER9ruX z!=%jSs#D#FSJx$#P5DoeZBPH$tZ}@Grx9;k(zpbJAc62m4f+@QE1c&}{q|5SM~ZUN zCtm}L6sb80|Dj$F?%^%eO}QTmZVoXwhq@DE?yU0Ro6{eh>^#NMH^vWRg;)D5dRoJw z1{KasD`%{eMzf#)AX6g`-I+tZ^WSwY76?`E0zkY7hcDfg1vnedqRz>>J{l0R` z3aZ)|-kHHHzSUblT=rw>vB4~E4ZCpprb!%>i%&vPl)oFl&$#MXqWM-Hp?}mL&0

  • * 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
  • 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 Date: Fri, 15 Nov 2013 22:01:18 +1300 Subject: [PATCH 06/18] Update build, package and installer scripts for LuaInterface --- Makefile | 20 +++++++++++++++++--- packaging/package-all.sh | 2 +- packaging/windows/OpenRA.nsi | 4 ++++ 3 files changed, 22 insertions(+), 4 deletions(-) diff --git a/Makefile b/Makefile index 60685d8690..6c89414392 100644 --- a/Makefile +++ b/Makefile @@ -63,7 +63,7 @@ INSTALL_PROGRAM = $(INSTALL) -m755 INSTALL_DATA = $(INSTALL) -m644 # program targets -CORE = fileformats rcg rgl rsdl rnull game utility geoip irc +CORE = fileformats rcg rgl rsdl rnull game utility geoip irc lua TOOLS = editor tsbuild ralint VERSION = $(shell git name-rev --name-only --tags --no-undefined HEAD 2>/dev/null || echo git-`git rev-parse --short HEAD`) @@ -105,6 +105,14 @@ irc_LIBS = $(COMMON_LIBS) $(irc_DEPS) PROGRAMS += irc irc: $(irc_TARGET) +lua_SRCS := $(shell find LuaInterface/ -name '*.cs') +lua_TARGET = LuaInterface.dll +lua_KIND = library +lua_DEPS = $(fileformats_TARGET) +lua_LIBS = $(COMMON_LIBS) $(lua_DEPS) +PROGRAMS += lua +lua: $(lua_TARGET) + # Renderer dlls rsdl_SRCS := $(shell find OpenRA.Renderer.SdlCommon/ -iname '*.cs') rsdl_TARGET = OpenRA.Renderer.SdlCommon.dll @@ -149,8 +157,8 @@ STD_MOD_DEPS = $(STD_MOD_LIBS) $(ralint_TARGET) mod_ra_SRCS := $(shell find OpenRA.Mods.RA/ -iname '*.cs') mod_ra_TARGET = mods/ra/OpenRA.Mods.RA.dll mod_ra_KIND = library -mod_ra_DEPS = $(STD_MOD_DEPS) $(utility_TARGET) $(geoip_TARGET) $(irc_TARGET) -mod_ra_LIBS = $(COMMON_LIBS) $(STD_MOD_LIBS) $(utility_TARGET) $(geoip_TARGET) $(irc_TARGET) +mod_ra_DEPS = $(STD_MOD_DEPS) $(utility_TARGET) $(geoip_TARGET) $(irc_TARGET) $(lua_TARGET) +mod_ra_LIBS = $(COMMON_LIBS) $(STD_MOD_LIBS) $(utility_TARGET) $(geoip_TARGET) $(irc_TARGET) $(lua_TARGET) PROGRAMS += mod_ra mod_ra: $(mod_ra_TARGET) @@ -293,6 +301,8 @@ distclean: clean dependencies: @ $(CP_R) thirdparty/*.dl* . + @ $(CP_R) thirdparty/*.dylib . + @ $(CP_R) thirdparty/*.so . @ $(CP_R) thirdparty/Tao/* . version: mods/ra/mod.yaml mods/cnc/mod.yaml mods/d2k/mod.yaml @@ -336,6 +346,10 @@ install-core: default @$(INSTALL_PROGRAM) thirdparty/SharpFont.dll "$(DATA_INSTALL_DIR)" @$(CP) thirdparty/SharpFont.dll.config "$(DATA_INSTALL_DIR)" @$(INSTALL_PROGRAM) thirdparty/Mono.Nat.dll "$(DATA_INSTALL_DIR)" + @$(CP) thirdparty/LuaInterface.dll.config "$(DATA_INSTALL_DIR)" + @$(INSTALL_PROGRAM) thirdparty/liblua-linux32.so "$(DATA_INSTALL_DIR)" + @$(INSTALL_PROGRAM) thirdparty/liblua-linux64.so "$(DATA_INSTALL_DIR)" + @$(INSTALL_PROGRAM) thirdparty/liblua-osx.dylib "$(DATA_INSTALL_DIR)" @echo "#!/bin/sh" > openra @echo 'BINDIR=$$(dirname $$(readlink -f $$0))' >> openra diff --git a/packaging/package-all.sh b/packaging/package-all.sh index cd6df0f1fe..2f4e802596 100755 --- a/packaging/package-all.sh +++ b/packaging/package-all.sh @@ -34,7 +34,7 @@ FILES=('OpenRA.Game.exe' 'OpenRA.Editor.exe' 'OpenRA.Utility.exe' \ 'cg' 'glsl' 'mods/ra' 'mods/cnc' 'mods/d2k' \ 'AUTHORS' 'CHANGELOG' 'COPYING' \ 'README.html' 'CONTRIBUTING.html' 'DOCUMENTATION.html' \ -'global mix database.dat' 'GeoIP.dll' 'GeoIP.dat') +'global mix database.dat' 'GeoIP.dll' 'GeoIP.dat' 'LuaInterface.dll') echo "Copying files..." for i in "${FILES[@]}"; do diff --git a/packaging/windows/OpenRA.nsi b/packaging/windows/OpenRA.nsi index b87371864f..2c5d64629a 100644 --- a/packaging/windows/OpenRA.nsi +++ b/packaging/windows/OpenRA.nsi @@ -83,6 +83,8 @@ Section "Game" GAME File "${SRCDIR}\global mix database.dat" File "${SRCDIR}\GeoIP.dll" File "${SRCDIR}\GeoIP.dat" + File "${SRCDIR}\LuaInterface.dll" + File lua51.dll File OpenAL32.dll File SDL.dll File freetype6.dll @@ -201,6 +203,8 @@ Function ${UN}Clean Delete "$INSTDIR\global mix database.dat" Delete $INSTDIR\GeoIP.dat Delete $INSTDIR\GeoIP.dll + Delete $INSTDIR\LuaInterface.dll + Delete $INSTDIR\lua51.dll Delete $INSTDIR\OpenAL32.dll Delete $INSTDIR\SDL.dll Delete $INSTDIR\freetype6.dll From acd7efd957afcc1eb2b99f804a33b2cb4dd028ab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20Mail=C3=A4nder?= Date: Sat, 16 Nov 2013 11:29:13 +0100 Subject: [PATCH 07/18] install the Lua libraries on Mac OS and Linux --- packaging/linux/buildpackage.sh | 3 +++ packaging/osx/buildpackage.sh | 4 ++++ 2 files changed, 7 insertions(+) diff --git a/packaging/linux/buildpackage.sh b/packaging/linux/buildpackage.sh index d7d5827940..51caaeb5f7 100644 --- a/packaging/linux/buildpackage.sh +++ b/packaging/linux/buildpackage.sh @@ -25,6 +25,9 @@ cp *.sh "$PWD/packaging/linux/$ROOTDIR/usr/share/openra/" || exit 3 # Icons and .desktop files make install-shortcuts prefix="/usr" DESTDIR="$PWD/packaging/linux/$ROOTDIR" +# Remove Mac OS X libaries +rm -rf "$PWD/packaging/linux/$ROOTDIR/usr/lib/openra/liblua-osx.dylib" || exit 3 + cd packaging/linux ( diff --git a/packaging/osx/buildpackage.sh b/packaging/osx/buildpackage.sh index ded6a6f695..c511a3d8fe 100755 --- a/packaging/osx/buildpackage.sh +++ b/packaging/osx/buildpackage.sh @@ -21,6 +21,10 @@ cp -rv $2/* "OpenRA.app/Contents/Resources/" || exit 3 rm OpenRA.app/Contents/Resources/OpenRA.ico rm OpenRA.app/Contents/Resources/OpenRA.Editor.exe +# Install the stripped down Lua library +cp ../../liblua-osx.dylib OpenRA.app/Contents/Resources/ +cp ../../LuaInterface.dll.config OpenRA.app/Contents/Resources/ + # SDL2 is the only supported renderer rm -rf OpenRA.app/Contents/Resources/cg rm OpenRA.app/Contents/Resources/OpenRA.Renderer.Cg.dll From 3e5255d61952fdecf8952c6a3b0112c909e423b3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20Mail=C3=A4nder?= Date: Sat, 16 Nov 2013 11:21:33 +0100 Subject: [PATCH 08/18] remove old and misleading note --- packaging/package-all.sh | 2 -- 1 file changed, 2 deletions(-) diff --git a/packaging/package-all.sh b/packaging/package-all.sh index 2f4e802596..20d6d8ffeb 100755 --- a/packaging/package-all.sh +++ b/packaging/package-all.sh @@ -26,8 +26,6 @@ markdown CONTRIBUTING.md > CONTRIBUTING.html markdown DOCUMENTATION.md > DOCUMENTATION.html # List of files that are packaged on all platforms -# Note that the Tao dlls are shipped on all platforms except osx and that -# they are now installed to the game directory instead of placed in the gac FILES=('OpenRA.Game.exe' 'OpenRA.Editor.exe' 'OpenRA.Utility.exe' \ 'OpenRA.FileFormats.dll' 'OpenRA.Renderer.SdlCommon.dll' 'OpenRA.Renderer.Sdl2.dll' 'OpenRA.Renderer.Cg.dll' 'OpenRA.Renderer.Gl.dll' 'OpenRA.Renderer.Null.dll' 'OpenRA.Irc.dll' \ 'FreeSans.ttf' 'FreeSansBold.ttf' \ From 6498e0ec7a6f3361123e1386153e5cd02eb6e6e4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20Mail=C3=A4nder?= Date: Sat, 16 Nov 2013 11:27:01 +0100 Subject: [PATCH 09/18] moved KDE stuff into local git ignore --- .gitignore | 4 ---- 1 file changed, 4 deletions(-) diff --git a/.gitignore b/.gitignore index 16b1efb7bb..ec4a2bd747 100644 --- a/.gitignore +++ b/.gitignore @@ -47,10 +47,6 @@ OpenRA.Launcher.Mac/OpenRA.xcodeproj/*.perspectivev3 OpenRA.Launcher.Mac/OpenRA.xcodeproj/*.mode1v3 *.resources -# KDE -*.kate-swp -*.directory - # auto-generated documentation DOCUMENTATION.md *.html From 17a024202b692bd6f30fb15aa7c005c4bdca19b5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20Mail=C3=A4nder?= Date: Sat, 16 Nov 2013 11:35:54 +0100 Subject: [PATCH 10/18] we now have .so and .dylib --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index ec4a2bd747..1e57bc443d 100644 --- a/.gitignore +++ b/.gitignore @@ -19,6 +19,8 @@ mods/*/*.dll *.pdb *.mdb *.exe +/*.so +/*.dylib # backup files by various editors *~ From a0d0bc983019b6d34c2860d6270eb9c93dc98cad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20Mail=C3=A4nder?= Date: Sat, 16 Nov 2013 11:36:03 +0100 Subject: [PATCH 11/18] clean up exe laying around elsewhere --- .gitignore | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/.gitignore b/.gitignore index 1e57bc443d..24244cd849 100644 --- a/.gitignore +++ b/.gitignore @@ -14,13 +14,14 @@ _ReSharper.*/ # binaries mods/*/*.dll +mods/*/*.mdb /*.dll /*.dll.config -*.pdb -*.mdb -*.exe /*.so /*.dylib +/*.pdb +/*.mdb +/*.exe # backup files by various editors *~ From 1d60b86b9b3347c9aa61065234b52f4ee3314e56 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20Mail=C3=A4nder?= Date: Sat, 16 Nov 2013 11:51:58 +0100 Subject: [PATCH 12/18] fix indentions --- Makefile | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Makefile b/Makefile index 6c89414392..6656a01523 100644 --- a/Makefile +++ b/Makefile @@ -77,7 +77,7 @@ fileformats_SRCS := $(shell find OpenRA.FileFormats/ -iname '*.cs') fileformats_TARGET = OpenRA.FileFormats.dll fileformats_KIND = library fileformats_LIBS = $(COMMON_LIBS) thirdparty/Tao/Tao.Sdl.dll System.Windows.Forms.dll -PROGRAMS = fileformats +PROGRAMS = fileformats fileformats: $(fileformats_TARGET) geoip_SRCS := $(shell find GeoIP/ -iname '*.cs') @@ -134,13 +134,13 @@ rgl_DEPS = $(fileformats_TARGET) $(game_TARGET) $(rsdl_TARGET) rgl_LIBS = $(COMMON_LIBS) thirdparty/Tao/Tao.OpenGl.dll $(rgl_DEPS) rsdl2_SRCS := $(shell find OpenRA.Renderer.Sdl2/ -iname '*.cs') -rsdl2_TARGET = OpenRA.Renderer.Sdl2.dll +rsdl2_TARGET = OpenRA.Renderer.Sdl2.dll rsdl2_KIND = library rsdl2_DEPS = $(fileformats_TARGET) $(game_TARGET) $(rsdl_TARGET) $(rgl_TARGET) rsdl2_LIBS = $(COMMON_LIBS) thirdparty/Tao/Tao.OpenGl.dll thirdparty/SDL2\#.dll $(rsdl2_DEPS) rnull_SRCS := $(shell find OpenRA.Renderer.Null/ -iname '*.cs') -rnull_TARGET = OpenRA.Renderer.Null.dll +rnull_TARGET = OpenRA.Renderer.Null.dll rnull_KIND = library rnull_DEPS = $(fileformats_TARGET) $(game_TARGET) rnull_LIBS = $(COMMON_LIBS) $(rnull_DEPS) @@ -197,7 +197,7 @@ editor_TARGET = OpenRA.Editor.exe editor_KIND = winexe editor_DEPS = $(fileformats_TARGET) $(game_TARGET) editor_LIBS = $(COMMON_LIBS) System.Windows.Forms.dll System.Data.dll $(editor_DEPS) -editor_EXTRA = -resource:OpenRA.Editor.Form1.resources -resource:OpenRA.Editor.MapSelect.resources +editor_EXTRA = -resource:OpenRA.Editor.Form1.resources -resource:OpenRA.Editor.MapSelect.resources editor_FLAGS = -win32icon:OpenRA.Editor/OpenRA.Editor.Icon.ico PROGRAMS += editor @@ -233,7 +233,7 @@ tsbuild_KIND = winexe tsbuild_DEPS = $(fileformats_TARGET) $(game_TARGET) tsbuild_LIBS = $(COMMON_LIBS) $(tsbuild_DEPS) System.Windows.Forms.dll tsbuild_EXTRA = -resource:OpenRA.TilesetBuilder.FormBuilder.resources -resource:OpenRA.TilesetBuilder.FormNew.resources -resource:OpenRA.TilesetBuilder.Surface.resources -PROGRAMS += tsbuild +PROGRAMS += tsbuild OpenRA.TilesetBuilder.FormBuilder.resources: resgen2 OpenRA.TilesetBuilder/FormBuilder.resx OpenRA.TilesetBuilder.FormBuilder.resources 1> /dev/null OpenRA.TilesetBuilder.FormNew.resources: @@ -251,7 +251,7 @@ utility_TARGET = OpenRA.Utility.exe utility_KIND = exe utility_DEPS = $(fileformats_TARGET) $(game_TARGET) utility_LIBS = $(COMMON_LIBS) $(utility_DEPS) thirdparty/ICSharpCode.SharpZipLib.dll System.Windows.Forms.dll -PROGRAMS += utility +PROGRAMS += utility utility: $(utility_TARGET) From 2062a1bf9b9867f2bbc5841397a86fd0f24079a7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20Mail=C3=A4nder?= Date: Sat, 16 Nov 2013 11:56:35 +0100 Subject: [PATCH 13/18] install openra to /usr/lib now that we ship native libraries --- Makefile | 4 +++- packaging/linux/buildpackage.sh | 2 +- packaging/linux/rpm/buildpackage.sh | 2 +- 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/Makefile b/Makefile index 6656a01523..6692fba35f 100644 --- a/Makefile +++ b/Makefile @@ -48,8 +48,10 @@ prefix ?= /usr/local datarootdir ?= $(prefix)/share datadir ?= $(datarootdir) bindir ?= $(prefix)/bin +libexecdir ?= $(prefix)/lib BIN_INSTALL_DIR = $(DESTDIR)$(bindir) -DATA_INSTALL_DIR = $(DESTDIR)$(datadir)/openra +# TODO: separate data and binaries properly +DATA_INSTALL_DIR = $(DESTDIR)$(libexecdir)/openra # install tools RM = rm diff --git a/packaging/linux/buildpackage.sh b/packaging/linux/buildpackage.sh index 51caaeb5f7..3aa9fe6afe 100644 --- a/packaging/linux/buildpackage.sh +++ b/packaging/linux/buildpackage.sh @@ -20,7 +20,7 @@ cd ../.. make install-all prefix="/usr" DESTDIR="$PWD/packaging/linux/$ROOTDIR" # Launch scripts (executed by Desura) -cp *.sh "$PWD/packaging/linux/$ROOTDIR/usr/share/openra/" || exit 3 +cp *.sh "$PWD/packaging/linux/$ROOTDIR/usr/lib/openra/" || exit 3 # Icons and .desktop files make install-shortcuts prefix="/usr" DESTDIR="$PWD/packaging/linux/$ROOTDIR" diff --git a/packaging/linux/rpm/buildpackage.sh b/packaging/linux/rpm/buildpackage.sh index b640d3fdde..b5e88ee430 100755 --- a/packaging/linux/rpm/buildpackage.sh +++ b/packaging/linux/rpm/buildpackage.sh @@ -13,7 +13,7 @@ sed -i "s/{VERSION_FIELD}/$PKGVERSION/" openra.spec rootdir=`readlink -f $2` sed -i "s|{ROOT_DIR}|$rootdir|" openra.spec -for x in `find $rootdir/usr/share/openra -type d` +for x in `find $rootdir/usr/lib/openra -type d` do y="${x#$rootdir}" sed -i "/%files/ a ${y}" openra.spec From c257b3e74b40cb2de7ff45279530b0ef544909c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20Mail=C3=A4nder?= Date: Sat, 16 Nov 2013 12:03:31 +0100 Subject: [PATCH 14/18] fix duplicate / --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 6692fba35f..e42777a1e8 100644 --- a/Makefile +++ b/Makefile @@ -371,7 +371,7 @@ install-tools: tools @echo "#!/bin/sh" > openra-editor @echo 'BINDIR=$$(dirname $$(readlink -f $$0))' >> openra-editor @echo 'ROOTDIR="$${BINDIR%'"$(bindir)"'}"' >> openra-editor - @echo 'DATADIR="$${ROOTDIR}/'"$(datadir)"'"' >> openra-editor + @echo 'DATADIR="$${ROOTDIR}'"$(datadir)"'"' >> openra-editor @echo 'cd "$${DATADIR}/openra"' >> openra-editor @echo 'exec mono OpenRA.Editor.exe "$$@"' >> openra-editor @$(INSTALL_DIR) "$(BIN_INSTALL_DIR)" From 5f92b6921168ead03f7f57127ad14665355fc042 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20Mail=C3=A4nder?= Date: Sat, 16 Nov 2013 14:08:00 +0100 Subject: [PATCH 15/18] don't terminate the RPM build because we ship .so in noarch TODO: this is horrible! --- packaging/linux/rpm/openra.spec | 1 + 1 file changed, 1 insertion(+) diff --git a/packaging/linux/rpm/openra.spec b/packaging/linux/rpm/openra.spec index 4d5bcfcef3..87940ca81a 100644 --- a/packaging/linux/rpm/openra.spec +++ b/packaging/linux/rpm/openra.spec @@ -1,6 +1,7 @@ %define name openra %define version {VERSION_FIELD} %define root {ROOT_DIR} +%define _binaries_in_noarch_packages_terminate_build 0 Name: %{name} Version: %{version} Release: 1 From fcd8997c2525897dde264e66288a827a30eb0b13 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20Mail=C3=A4nder?= Date: Sat, 16 Nov 2013 14:21:30 +0100 Subject: [PATCH 16/18] break RPM auto dependency generation completely apart so it installs this noarch which is in fact x86_64 (because of the build server) even on i586 --- packaging/linux/rpm/openra.spec | 3 +++ 1 file changed, 3 insertions(+) diff --git a/packaging/linux/rpm/openra.spec b/packaging/linux/rpm/openra.spec index 87940ca81a..bb6083c567 100644 --- a/packaging/linux/rpm/openra.spec +++ b/packaging/linux/rpm/openra.spec @@ -2,6 +2,9 @@ %define version {VERSION_FIELD} %define root {ROOT_DIR} %define _binaries_in_noarch_packages_terminate_build 0 +%define _use_internal_dependency_generator 0 +%define __find_provides "" +%define __find_requires "" Name: %{name} Version: %{version} Release: 1 From 94d19362862024b67821345544090a7ec8f98cd3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matthias=20Mail=C3=A4nder?= Date: Sat, 16 Nov 2013 14:25:47 +0100 Subject: [PATCH 17/18] fix shortcut on Linux --- Makefile | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Makefile b/Makefile index e42777a1e8..eb5c4a81fa 100644 --- a/Makefile +++ b/Makefile @@ -356,8 +356,8 @@ install-core: default @echo "#!/bin/sh" > openra @echo 'BINDIR=$$(dirname $$(readlink -f $$0))' >> openra @echo 'ROOTDIR="$${BINDIR%'"$(bindir)"'}"' >> openra - @echo 'DATADIR="$${ROOTDIR}'"$(datadir)"'"' >> openra - @echo 'cd "$${DATADIR}/openra"' >> openra + @echo 'EXECDIR="$${ROOTDIR}'"$(libexecdir)"'"' >> openra + @echo 'cd "$${EXECDIR}/openra"' >> openra @echo 'exec mono OpenRA.Game.exe "$$@"' >> openra @$(INSTALL_DIR) "$(BIN_INSTALL_DIR)" @$(INSTALL_PROGRAM) -m +rx openra "$(BIN_INSTALL_DIR)" @@ -371,8 +371,8 @@ install-tools: tools @echo "#!/bin/sh" > openra-editor @echo 'BINDIR=$$(dirname $$(readlink -f $$0))' >> openra-editor @echo 'ROOTDIR="$${BINDIR%'"$(bindir)"'}"' >> openra-editor - @echo 'DATADIR="$${ROOTDIR}'"$(datadir)"'"' >> openra-editor - @echo 'cd "$${DATADIR}/openra"' >> openra-editor + @echo 'EXECDIR="$${ROOTDIR}'"$(libexecdir)"'"' >> openra-editor + @echo 'cd "$${EXECDIR}/openra"' >> openra-editor @echo 'exec mono OpenRA.Editor.exe "$$@"' >> openra-editor @$(INSTALL_DIR) "$(BIN_INSTALL_DIR)" @$(INSTALL_PROGRAM) -m +rx openra-editor "$(BIN_INSTALL_DIR)" From 6327a88b680f5d2a69f176781acb243da3592a69 Mon Sep 17 00:00:00 2001 From: ScottNZ Date: Mon, 18 Nov 2013 20:48:38 +1300 Subject: [PATCH 18/18] Update CHANGELOG for Lua support and 'make install' changes --- CHANGELOG | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG b/CHANGELOG index cf0f4d2d48..7c658c3056 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -77,12 +77,14 @@ NEW: Fixed a desync related to projectile contrails. Fixed corrupted replays (which would immediately desync). Removed runtime mod merging. + Added support for map scripting with Lua. Build system and packages: Added GeoIP to Makefile so it is installed properly. Added desktop shortcut creation support to the Makefile and Windows installer. COPYING and CHANGELOG are now shipped on all platforms. Fixed 'make docs' crashing when the game assets are not installed. Renamed Game.Mods launch argument to Game.Mod. + Linux packages now install to /usr/lib/openra for consistency with other Mono applications. Mod / Custom map compatibility: Mods can now include traits from TD and D2K in RA. New sections MapFolders and Translations added to mod.yaml.