Commit 5fc72461 authored by Vinicius Jarina's avatar Vinicius Jarina
Browse files

Mono-style format.

parent a0e1671c
......@@ -22,7 +22,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
using System.Reflection;
using System.Collections.Generic;
......@@ -41,143 +40,125 @@ namespace LuaInterface
*/
class CheckType
{
private Dictionary<long, ExtractValue> extractValues = new Dictionary<long, ExtractValue>();
private Dictionary<long, ExtractValue> extractValues = new Dictionary<long, ExtractValue> ();
private ExtractValue extractNetObject;
private ObjectTranslator translator;
public CheckType(ObjectTranslator translator)
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);
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)
internal ExtractValue getExtractor (IReflect paramType)
{
return getExtractor(paramType.UnderlyingSystemType);
return getExtractor (paramType.UnderlyingSystemType);
}
internal ExtractValue getExtractor(Type paramType)
internal ExtractValue getExtractor (Type paramType)
{
if(paramType.IsByRef)
paramType = paramType.GetElementType();
if (paramType.IsByRef)
paramType = paramType.GetElementType ();
long runtimeHandleValue = paramType.TypeHandle.Value.ToInt64();
return extractValues.ContainsKey(runtimeHandleValue) ? extractValues[runtimeHandleValue] : extractNetObject;
long runtimeHandleValue = paramType.TypeHandle.Value.ToInt64 ();
return extractValues.ContainsKey (runtimeHandleValue) ? extractValues [runtimeHandleValue] : extractNetObject;
}
internal ExtractValue checkType(LuaCore.lua_State luaState, int stackPos, Type paramType)
internal ExtractValue checkType (LuaCore.lua_State luaState, int stackPos, Type paramType)
{
var luatype = LuaLib.lua_type(luaState, stackPos);
var luatype = LuaLib.lua_type (luaState, stackPos);
if(paramType.IsByRef)
paramType = paramType.GetElementType();
if (paramType.IsByRef)
paramType = paramType.GetElementType ();
var underlyingType = Nullable.GetUnderlyingType(paramType);
var underlyingType = Nullable.GetUnderlyingType (paramType);
if(!underlyingType.IsNull())
if (!underlyingType.IsNull ())
paramType = underlyingType; // Silently convert nullable types to their non null requics
long runtimeHandleValue = paramType.TypeHandle.Value.ToInt64();
long runtimeHandleValue = paramType.TypeHandle.Value.ToInt64 ();
if(paramType.Equals(typeof(object)))
return extractValues[runtimeHandleValue];
if (paramType.Equals (typeof(object)))
return extractValues [runtimeHandleValue];
//CP: Added support for generic parameters
if(paramType.IsGenericParameter)
{
if(luatype == LuaTypes.Boolean)
return extractValues[typeof(bool).TypeHandle.Value.ToInt64()];
else if(luatype == LuaTypes.String)
return extractValues[typeof(string).TypeHandle.Value.ToInt64()];
else if(luatype == LuaTypes.Table)
return extractValues[typeof(LuaTable).TypeHandle.Value.ToInt64()];
else if(luatype == LuaTypes.UserData)
return extractValues[typeof(object).TypeHandle.Value.ToInt64()];
else if(luatype == LuaTypes.Function)
return extractValues[typeof(LuaFunction).TypeHandle.Value.ToInt64()];
else if(luatype == LuaTypes.Number)
return extractValues[typeof(double).TypeHandle.Value.ToInt64()];
if (paramType.IsGenericParameter) {
if (luatype == LuaTypes.Boolean)
return extractValues [typeof(bool).TypeHandle.Value.ToInt64 ()];
else if (luatype == LuaTypes.String)
return extractValues [typeof(string).TypeHandle.Value.ToInt64 ()];
else if (luatype == LuaTypes.Table)
return extractValues [typeof(LuaTable).TypeHandle.Value.ToInt64 ()];
else if (luatype == LuaTypes.UserData)
return extractValues [typeof(object).TypeHandle.Value.ToInt64 ()];
else if (luatype == LuaTypes.Function)
return extractValues [typeof(LuaFunction).TypeHandle.Value.ToInt64 ()];
else if (luatype == LuaTypes.Number)
return extractValues [typeof(double).TypeHandle.Value.ToInt64 ()];
//else
//;//an unsupported type was encountered
}
if(LuaLib.lua_isnumber(luaState, stackPos))
return extractValues[runtimeHandleValue];
if (LuaLib.lua_isnumber (luaState, stackPos))
return extractValues [runtimeHandleValue];
if(paramType == typeof(bool))
{
if(LuaLib.lua_isboolean(luaState, stackPos))
return extractValues[runtimeHandleValue];
}
else if(paramType == typeof(string))
{
if(LuaLib.lua_isstring(luaState, stackPos))
return extractValues[runtimeHandleValue];
else if(luatype == LuaTypes.Nil)
if (paramType == typeof(bool)) {
if (LuaLib.lua_isboolean (luaState, stackPos))
return extractValues [runtimeHandleValue];
} else if (paramType == typeof(string)) {
if (LuaLib.lua_isstring (luaState, stackPos))
return extractValues [runtimeHandleValue];
else if (luatype == LuaTypes.Nil)
return extractNetObject; // kevinh - silently convert nil to a null string pointer
}
else if(paramType == typeof(LuaTable))
{
if(luatype == LuaTypes.Table)
return extractValues[runtimeHandleValue];
}
else if(paramType == typeof(LuaUserData))
{
if(luatype == LuaTypes.UserData)
return extractValues[runtimeHandleValue];
}
else if(paramType == typeof(LuaFunction))
{
if(luatype == LuaTypes.Function)
return extractValues[runtimeHandleValue];
}
else if(typeof(Delegate).IsAssignableFrom(paramType) && luatype == LuaTypes.Function)
return new ExtractValue(new DelegateGenerator(translator, paramType).extractGenerated);
else if(paramType.IsInterface && luatype == LuaTypes.Table)
return new ExtractValue(new ClassGenerator(translator, paramType).extractGenerated);
else if((paramType.IsInterface || paramType.IsClass) && luatype == LuaTypes.Nil)
{
} else if (paramType == typeof(LuaTable)) {
if (luatype == LuaTypes.Table)
return extractValues [runtimeHandleValue];
} else if (paramType == typeof(LuaUserData)) {
if (luatype == LuaTypes.UserData)
return extractValues [runtimeHandleValue];
} else if (paramType == typeof(LuaFunction)) {
if (luatype == LuaTypes.Function)
return extractValues [runtimeHandleValue];
} else if (typeof(Delegate).IsAssignableFrom (paramType) && luatype == LuaTypes.Function)
return new ExtractValue (new DelegateGenerator (translator, paramType).extractGenerated);
else if (paramType.IsInterface && luatype == LuaTypes.Table)
return new ExtractValue (new ClassGenerator (translator, paramType).extractGenerated);
else if ((paramType.IsInterface || paramType.IsClass) && luatype == LuaTypes.Nil) {
// kevinh - allow nil to be silently converted to null - extractNetObject will return null when the item ain't found
return extractNetObject;
}
else if(LuaLib.lua_type(luaState, stackPos) == LuaTypes.Table)
{
if(LuaLib.luaL_getmetafield(luaState, stackPos, "__index"))
{
object obj = translator.getNetObject(luaState, -1);
LuaLib.lua_settop(luaState, -2);
if(!obj.IsNull() && paramType.IsAssignableFrom(obj.GetType()))
} else if (LuaLib.lua_type (luaState, stackPos) == LuaTypes.Table) {
if (LuaLib.luaL_getmetafield (luaState, stackPos, "__index")) {
object obj = translator.getNetObject (luaState, -1);
LuaLib.lua_settop (luaState, -2);
if (!obj.IsNull () && paramType.IsAssignableFrom (obj.GetType ()))
return extractNetObject;
}
else
} else
return null;
}
else
{
object obj = translator.getNetObject(luaState, stackPos);
if(!obj.IsNull() && paramType.IsAssignableFrom(obj.GetType()))
} else {
object obj = translator.getNetObject (luaState, stackPos);
if (!obj.IsNull () && paramType.IsAssignableFrom (obj.GetType ()))
return extractNetObject;
}
......@@ -189,179 +170,171 @@ namespace LuaInterface
* index stackPos as the desired type if it can, or null
* otherwise.
*/
private object getAsSbyte(LuaCore.lua_State luaState, int stackPos)
private object getAsSbyte (LuaCore.lua_State luaState, int stackPos)
{
sbyte retVal = (sbyte)LuaLib.lua_tonumber(luaState, stackPos);
if(retVal == 0 && !LuaLib.lua_isnumber(luaState, stackPos))
sbyte retVal = (sbyte)LuaLib.lua_tonumber (luaState, stackPos);
if (retVal == 0 && !LuaLib.lua_isnumber (luaState, stackPos))
return null;
return retVal;
}
private object getAsByte(LuaCore.lua_State luaState, int stackPos)
private object getAsByte (LuaCore.lua_State luaState, int stackPos)
{
byte retVal = (byte)LuaLib.lua_tonumber(luaState, stackPos);
if(retVal == 0 && !LuaLib.lua_isnumber(luaState, stackPos))
byte retVal = (byte)LuaLib.lua_tonumber (luaState, stackPos);
if (retVal == 0 && !LuaLib.lua_isnumber (luaState, stackPos))
return null;
return retVal;
}
private object getAsShort(LuaCore.lua_State luaState, int stackPos)
private object getAsShort (LuaCore.lua_State luaState, int stackPos)
{
short retVal = (short)LuaLib.lua_tonumber(luaState, stackPos);
if(retVal == 0 && !LuaLib.lua_isnumber(luaState, stackPos))
short retVal = (short)LuaLib.lua_tonumber (luaState, stackPos);
if (retVal == 0 && !LuaLib.lua_isnumber (luaState, stackPos))
return null;
return retVal;
}
private object getAsUshort(LuaCore.lua_State luaState, int stackPos)
private object getAsUshort (LuaCore.lua_State luaState, int stackPos)
{
ushort retVal = (ushort)LuaLib.lua_tonumber(luaState, stackPos);
if(retVal == 0 && !LuaLib.lua_isnumber(luaState, stackPos))
ushort retVal = (ushort)LuaLib.lua_tonumber (luaState, stackPos);
if (retVal == 0 && !LuaLib.lua_isnumber (luaState, stackPos))
return null;
return retVal;
}
private object getAsInt(LuaCore.lua_State luaState, int stackPos)
private object getAsInt (LuaCore.lua_State luaState, int stackPos)
{
int retVal = (int)LuaLib.lua_tonumber(luaState, stackPos);
if(retVal == 0 && !LuaLib.lua_isnumber(luaState, stackPos))
int retVal = (int)LuaLib.lua_tonumber (luaState, stackPos);
if (retVal == 0 && !LuaLib.lua_isnumber (luaState, stackPos))
return null;
return retVal;
}
private object getAsUint(LuaCore.lua_State luaState, int stackPos)
private object getAsUint (LuaCore.lua_State luaState, int stackPos)
{
uint retVal = (uint)LuaLib.lua_tonumber(luaState, stackPos);
if(retVal == 0 && !LuaLib.lua_isnumber(luaState, stackPos))
uint retVal = (uint)LuaLib.lua_tonumber (luaState, stackPos);
if (retVal == 0 && !LuaLib.lua_isnumber (luaState, stackPos))
return null;
return retVal;
}
private object getAsLong(LuaCore.lua_State luaState, int stackPos)
private object getAsLong (LuaCore.lua_State luaState, int stackPos)
{
long retVal = (long)LuaLib.lua_tonumber(luaState, stackPos);
if(retVal == 0 && !LuaLib.lua_isnumber(luaState, stackPos))
long retVal = (long)LuaLib.lua_tonumber (luaState, stackPos);
if (retVal == 0 && !LuaLib.lua_isnumber (luaState, stackPos))
return null;
return retVal;
}
private object getAsUlong(LuaCore.lua_State luaState, int stackPos)
private object getAsUlong (LuaCore.lua_State luaState, int stackPos)
{
ulong retVal = (ulong)LuaLib.lua_tonumber(luaState, stackPos);
if(retVal == 0 && !LuaLib.lua_isnumber(luaState, stackPos))
ulong retVal = (ulong)LuaLib.lua_tonumber (luaState, stackPos);
if (retVal == 0 && !LuaLib.lua_isnumber (luaState, stackPos))
return null;
return retVal;
}
private object getAsDouble(LuaCore.lua_State luaState, int stackPos)
private object getAsDouble (LuaCore.lua_State luaState, int stackPos)
{
double retVal = LuaLib.lua_tonumber(luaState, stackPos);
if(retVal == 0 && !LuaLib.lua_isnumber(luaState, stackPos))
double retVal = LuaLib.lua_tonumber (luaState, stackPos);
if (retVal == 0 && !LuaLib.lua_isnumber (luaState, stackPos))
return null;
return retVal;
}
private object getAsChar(LuaCore.lua_State luaState, int stackPos)
private object getAsChar (LuaCore.lua_State luaState, int stackPos)
{
char retVal = (char)LuaLib.lua_tonumber(luaState, stackPos);
if(retVal == 0 && !LuaLib.lua_isnumber(luaState, stackPos))
char retVal = (char)LuaLib.lua_tonumber (luaState, stackPos);
if (retVal == 0 && !LuaLib.lua_isnumber (luaState, stackPos))
return null;
return retVal;
}
private object getAsFloat(LuaCore.lua_State luaState, int stackPos)
private object getAsFloat (LuaCore.lua_State luaState, int stackPos)
{
float retVal = (float)LuaLib.lua_tonumber(luaState, stackPos);
if(retVal == 0 && !LuaLib.lua_isnumber(luaState, stackPos))
float retVal = (float)LuaLib.lua_tonumber (luaState, stackPos);
if (retVal == 0 && !LuaLib.lua_isnumber (luaState, stackPos))
return null;
return retVal;
}
private object getAsDecimal(LuaCore.lua_State luaState, int stackPos)
private object getAsDecimal (LuaCore.lua_State luaState, int stackPos)
{
decimal retVal = (decimal)LuaLib.lua_tonumber(luaState, stackPos);
if(retVal == 0 && !LuaLib.lua_isnumber(luaState, stackPos))
decimal retVal = (decimal)LuaLib.lua_tonumber (luaState, stackPos);
if (retVal == 0 && !LuaLib.lua_isnumber (luaState, stackPos))
return null;
return retVal;
}
private object getAsBoolean(LuaCore.lua_State luaState, int stackPos)
private object getAsBoolean (LuaCore.lua_State luaState, int stackPos)
{
return LuaLib.lua_toboolean(luaState, stackPos);
return LuaLib.lua_toboolean (luaState, stackPos);
}
private object getAsString(LuaCore.lua_State luaState, int stackPos)
private object getAsString (LuaCore.lua_State luaState, int stackPos)
{
string retVal = LuaLib.lua_tostring(luaState, stackPos).ToString();
if(retVal == string.Empty && !LuaLib.lua_isstring(luaState, stackPos))
string retVal = LuaLib.lua_tostring (luaState, stackPos).ToString ();
if (retVal == string.Empty && !LuaLib.lua_isstring (luaState, stackPos))
return null;
return retVal;
}
private object getAsTable(LuaCore.lua_State luaState, int stackPos)
private object getAsTable (LuaCore.lua_State luaState, int stackPos)
{
return translator.getTable(luaState, stackPos);
return translator.getTable (luaState, stackPos);
}
private object getAsFunction(LuaCore.lua_State luaState, int stackPos)
private object getAsFunction (LuaCore.lua_State luaState, int stackPos)
{
return translator.getFunction(luaState, stackPos);
return translator.getFunction (luaState, stackPos);
}
private object getAsUserdata(LuaCore.lua_State luaState, int stackPos)
private object getAsUserdata (LuaCore.lua_State luaState, int stackPos)
{
return translator.getUserData(luaState, stackPos);
return translator.getUserData (luaState, stackPos);
}
public object getAsObject(LuaCore.lua_State luaState, int stackPos)
{
if(LuaLib.lua_type(luaState, stackPos) == LuaTypes.Table)
{
if(LuaLib.luaL_getmetafield(luaState, stackPos, "__index"))
public object getAsObject (LuaCore.lua_State luaState, int stackPos)
{
if(LuaLib.luaL_checkmetatable(luaState, -1))
{
LuaLib.lua_insert(luaState, stackPos);
LuaLib.lua_remove(luaState, stackPos+1);
}
else
LuaLib.lua_settop(luaState, -2);
if (LuaLib.lua_type (luaState, stackPos) == LuaTypes.Table) {
if (LuaLib.luaL_getmetafield (luaState, stackPos, "__index")) {
if (LuaLib.luaL_checkmetatable (luaState, -1)) {
LuaLib.lua_insert (luaState, stackPos);
LuaLib.lua_remove (luaState, stackPos + 1);
} else
LuaLib.lua_settop (luaState, -2);
}
}
object obj = translator.getObject(luaState, stackPos);
object obj = translator.getObject (luaState, stackPos);
return obj;
}
public object getAsNetObject(LuaCore.lua_State luaState, int stackPos)
public object getAsNetObject (LuaCore.lua_State luaState, int stackPos)
{
object obj = translator.getNetObject(luaState, stackPos);
object obj = translator.getNetObject (luaState, stackPos);
if(obj.IsNull() && LuaLib.lua_type(luaState, stackPos) == LuaTypes.Table)
{
if(LuaLib.luaL_getmetafield(luaState, stackPos, "__index"))
{
if(LuaLib.luaL_checkmetatable(luaState, -1))
{
LuaLib.lua_insert(luaState, stackPos);
LuaLib.lua_remove(luaState, stackPos+1);
obj = translator.getNetObject(luaState, stackPos);
}
else
LuaLib.lua_settop(luaState, -2);
if (obj.IsNull () && LuaLib.lua_type (luaState, stackPos) == LuaTypes.Table) {
if (LuaLib.luaL_getmetafield (luaState, stackPos, "__index")) {
if (LuaLib.luaL_checkmetatable (luaState, -1)) {
LuaLib.lua_insert (luaState, stackPos);
LuaLib.lua_remove (luaState, stackPos + 1);
obj = translator.getNetObject (luaState, stackPos);
} else
LuaLib.lua_settop (luaState, -2);
}
}
......
......@@ -21,7 +21,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
namespace LuaInterface.Config
......
......@@ -22,7 +22,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
namespace LuaInterface.Event
......@@ -37,13 +36,12 @@ namespace LuaInterface.Event
{
private readonly LuaCore.lua_Debug luaDebug;
public DebugHookEventArgs(LuaCore.lua_Debug luaDebug)
public DebugHookEventArgs (LuaCore.lua_Debug luaDebug)
{
this.luaDebug = luaDebug;
}
public LuaCore.lua_Debug LuaDebug
{
public LuaCore.lua_Debug LuaDebug {
get { return luaDebug; }
}
}
......
......@@ -22,7 +22,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
namespace LuaInterface.Event
......
......@@ -22,7 +22,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
namespace LuaInterface.Event
......
......@@ -22,7 +22,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
namespace LuaInterface.Event
......@@ -31,12 +30,11 @@ namespace LuaInterface.Event
{
private readonly Exception m_Exception;
public Exception Exception
{
public Exception Exception {
get { return m_Exception; }
}
public HookExceptionEventArgs(Exception ex)
public HookExceptionEventArgs (Exception ex)
{
m_Exception = ex;
}
......
......@@ -22,7 +22,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
using System.Runtime.Serialization;
......@@ -34,19 +33,19 @@ namespace LuaInterface.Exceptions
[Serializable]
public class LuaException : Exception
{
public LuaException()
public LuaException ()
{
}
public LuaException(string message) : base(message)
public LuaException (string message) : base(message)
{
}
public LuaException(string message, Exception innerException) : base(message, innerException)
public LuaException (string message, Exception innerException) : base(message, innerException)
{
}
protected LuaException(SerializationInfo info, StreamingContext context) : base(info, context)
protected LuaException (SerializationInfo info, StreamingContext context) : base(info, context)
{
}
}
......
......@@ -22,7 +22,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
namespace LuaInterface.Exceptions
......@@ -36,6 +35,7 @@ namespace LuaInterface.Exceptions
/// Returns true if the exception has occured as the result of a .NET exception in user code
/// </summary>
public bool IsNetException { get; private set; }
private readonly string source;
/// <summary>
......@@ -48,7 +48,7 @@ namespace LuaInterface.Exceptions
/// </summary>
/// <param name="message">The message that describes the error.</param>
/// <param name="source">The position in the script where the exception was triggered.</param>
public LuaScriptException(string message, string source) : base(message)
public LuaScriptException (string message, string source) : base(message)
{
this.source = source;
}
......@@ -58,17 +58,17 @@ namespace LuaInterface.Exceptions
/// </summary>
/// <param name="innerException">The .NET exception triggered by user-code.</param>
/// <param name="source">The position in the script where the exception was triggered.</param>
public LuaScriptException(Exception innerException, string source)
public LuaScriptException (Exception innerException, string source)
: base("A .NET exception occured in user-code", innerException)
{
this.source = source;
this.IsNetException = true;
}
public override string ToString()
public override string ToString ()
{
// Prepend the error source
return GetType().FullName + ": " + source + Message;
return GetType ().FullName + ": " + source + Message;
}
}
}
\ No newline at end of file
......@@ -21,7 +21,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
namespace LuaInterface.Extensions
......@@ -38,7 +37,7 @@ namespace LuaInterface.Extensions
/// <returns>
/// <c>true</c> if the specified obj is null; otherwise, <c>false</c>.
/// </returns>
public static bool IsNull(this object obj)
public static bool IsNull (this object obj)
{
return (obj == null);
}
......
......@@ -22,7 +22,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
namespace LuaInterface
......@@ -39,15 +38,15 @@ namespace LuaInterface
private ObjectTranslator translator;
private Type klass;
public ClassGenerator(ObjectTranslator translator, Type klass)
public ClassGenerator (ObjectTranslator translator, Type klass)
{
this.translator = translator;
this.klass = klass;
}
public object extractGenerated(KopiLua.Lua.lua_State luaState, int stackPos)
public object extractGenerated (KopiLua.Lua.lua_State luaState, int stackPos)
{
return CodeGeneration.Instance.GetClassInstance(klass, translator.getTable(luaState, stackPos));
return CodeGeneration.Instance.GetClassInstance (klass, translator.getTable (luaState, stackPos));
}
}
}
\ No newline at end of file
......@@ -22,10 +22,10 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
using System.Threading;
using System.Reflection;
#if !MONOTOUCH
using System.Reflection.Emit;
#endif
......@@ -45,10 +45,10 @@ namespace LuaInterface
*/
class CodeGeneration
{
private Dictionary<Type, LuaClassType> classCollection = new Dictionary<Type, LuaClassType>();
private Dictionary<Type, Type> eventHandlerCollection = new Dictionary<Type, Type>();
private Dictionary<Type, Type> delegateCollection = new Dictionary<Type, Type>();
private static readonly CodeGeneration instance = new CodeGeneration();
private Dictionary<Type, LuaClassType> classCollection = new Dictionary<Type, LuaClassType> ();
private Dictionary<Type, Type> eventHandlerCollection = new Dictionary<Type, Type> ();
private Dictionary<Type, Type> delegateCollection = new Dictionary<Type, Type> ();
private static readonly CodeGeneration instance = new CodeGeneration ();
private Type eventHandlerParent = typeof(LuaEventHandler);
private Type delegateParent = typeof(LuaDelegate);
private Type classHelper = typeof(LuaClassHelper);
......@@ -59,22 +59,22 @@ namespace LuaInterface
#endif
private int luaClassNumber = 1;
static CodeGeneration()
static CodeGeneration ()
{
}
private CodeGeneration()
private CodeGeneration ()
{
// Create an assembly name
assemblyName = new AssemblyName();
assemblyName = new AssemblyName ();
assemblyName.Name = "LuaInterface_generatedcode";
// Create a new assembly with one module.
#if !MONOTOUCH
newAssembly = Thread.GetDomain().DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
newModule = newAssembly.DefineDynamicModule("LuaInterface_generatedcode");
newAssembly = Thread.GetDomain ().DefineDynamicAssembly (assemblyName, AssemblyBuilderAccess.Run);
newModule = newAssembly.DefineDynamicModule ("LuaInterface_generatedcode");
#endif
}
......@@ -82,48 +82,46 @@ namespace LuaInterface
/*
* Singleton instance of the class
*/
public static CodeGeneration Instance
{
public static CodeGeneration Instance {
get { return instance; }
}
/*
* Generates an event handler that calls a Lua function
*/
private Type GenerateEvent(Type eventHandlerType)
private Type GenerateEvent (Type eventHandlerType)
{
#if MONOTOUCH
throw new NotImplementedException (" Emit not available on MonoTouch ");
#else
string typeName;
lock(this)
{
lock (this) {
typeName = "LuaGeneratedClass" + luaClassNumber;
luaClassNumber++;
}
// Define a public class in the assembly, called typeName
var myType = newModule.DefineType(typeName, TypeAttributes.Public, eventHandlerParent);
var myType = newModule.DefineType (typeName, TypeAttributes.Public, eventHandlerParent);
// Defines the handler method. Its signature is void(object, <subclassofEventArgs>)
var paramTypes = new Type[2];
paramTypes[0] = typeof(object);
paramTypes[1] = eventHandlerType;
paramTypes [0] = typeof(object);
paramTypes [1] = eventHandlerType;
var returnType = typeof(void);
var handleMethod = myType.DefineMethod("HandleEvent", MethodAttributes.Public | MethodAttributes.HideBySig, returnType, paramTypes);
var 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);
var miGenericEventHandler = eventHandlerParent.GetMethod("handleEvent");
generator.Emit(OpCodes.Call, miGenericEventHandler);
ILGenerator generator = handleMethod.GetILGenerator ();
generator.Emit (OpCodes.Ldarg_0);
generator.Emit (OpCodes.Ldarg_1);
generator.Emit (OpCodes.Ldarg_2);
var miGenericEventHandler = eventHandlerParent.GetMethod ("handleEvent");
generator.Emit (OpCodes.Call, miGenericEventHandler);
// returns
generator.Emit(OpCodes.Ret);
generator.Emit (OpCodes.Ret);
// creates the new type
return myType.CreateType();
return myType.CreateType ();
#endif
}
......@@ -131,201 +129,175 @@ namespace LuaInterface
* Generates a type that can be used for instantiating a delegate
* of the provided type, given a Lua function.
*/
private Type GenerateDelegate(Type delegateType)
private Type GenerateDelegate (Type delegateType)
{
#if MONOTOUCH
throw new NotImplementedException ("GenerateDelegate is not available on iOS, please register your LuaDelegate type with Lua.RegisterLuaDelegateType( yourDelegate, theLuaDelegateHandler) ");
#else
string typeName;
lock(this)
{
lock (this) {
typeName = "LuaGeneratedClass" + luaClassNumber;
luaClassNumber++;
}
// Define a public class in the assembly, called typeName
var myType = newModule.DefineType(typeName, TypeAttributes.Public, delegateParent);
var myType = newModule.DefineType (typeName, TypeAttributes.Public, delegateParent);
// Defines the delegate method with the same signature as the
// Invoke method of delegateType
var invokeMethod = delegateType.GetMethod("Invoke");
var paramInfo = invokeMethod.GetParameters();
var invokeMethod = delegateType.GetMethod ("Invoke");
var paramInfo = invokeMethod.GetParameters ();
var paramTypes = new Type[paramInfo.Length];
var returnType = invokeMethod.ReturnType;
// Counts out and ref params, for use later
int nOutParams = 0; int nOutAndRefParams = 0;
int nOutParams = 0;
int nOutAndRefParams = 0;
for(int i = 0; i < paramTypes.Length; i++)
{
paramTypes[i] = paramInfo[i].ParameterType;
for (int i = 0; i < paramTypes.Length; i++) {
paramTypes [i] = paramInfo [i].ParameterType;
if((!paramInfo[i].IsIn) && paramInfo[i].IsOut)
if ((!paramInfo [i].IsIn) && paramInfo [i].IsOut)
nOutParams++;
if(paramTypes[i].IsByRef)
if (paramTypes [i].IsByRef)
nOutAndRefParams++;
}
int[] refArgs = new int[nOutAndRefParams];
var delegateMethod = myType.DefineMethod("CallFunction", invokeMethod.Attributes, returnType, paramTypes);
var delegateMethod = myType.DefineMethod ("CallFunction", invokeMethod.Attributes, returnType, paramTypes);
// Generates the IL for the method
ILGenerator generator = delegateMethod.GetILGenerator( );
generator.DeclareLocal(typeof(object[])); // original arguments
generator.DeclareLocal(typeof(object[])); // with out-only arguments removed
generator.DeclareLocal(typeof(int[])); // indexes of out and ref arguments
ILGenerator generator = delegateMethod.GetILGenerator ();
generator.DeclareLocal (typeof(object[])); // original arguments
generator.DeclareLocal (typeof(object[])); // with out-only arguments removed
generator.DeclareLocal (typeof(int[])); // indexes of out and ref arguments
if(!(returnType == typeof(void))) // return value
generator.DeclareLocal(returnType);
if (!(returnType == typeof(void))) // return value
generator.DeclareLocal (returnType);
else
generator.DeclareLocal(typeof(object));
generator.DeclareLocal (typeof(object));
// Initializes local variables
generator.Emit(OpCodes.Ldc_I4, paramTypes.Length);
generator.Emit(OpCodes.Newarr, typeof(object));
generator.Emit(OpCodes.Stloc_0);
generator.Emit(OpCodes.Ldc_I4, paramTypes.Length-nOutParams);
generator.Emit(OpCodes.Newarr, typeof(object));
generator.Emit(OpCodes.Stloc_1);
generator.Emit(OpCodes.Ldc_I4, nOutAndRefParams);
generator.Emit(OpCodes.Newarr, typeof(int));
generator.Emit(OpCodes.Stloc_2);
generator.Emit (OpCodes.Ldc_I4, paramTypes.Length);
generator.Emit (OpCodes.Newarr, typeof(object));
generator.Emit (OpCodes.Stloc_0);
generator.Emit (OpCodes.Ldc_I4, paramTypes.Length - nOutParams);
generator.Emit (OpCodes.Newarr, typeof(object));
generator.Emit (OpCodes.Stloc_1);
generator.Emit (OpCodes.Ldc_I4, nOutAndRefParams);
generator.Emit (OpCodes.Newarr, typeof(int));
generator.Emit (OpCodes.Stloc_2);
// Stores the arguments in the local variables
for(int iArgs = 0, iInArgs = 0, iOutArgs = 0; iArgs < paramTypes.Length; iArgs++)
{
generator.Emit(OpCodes.Ldloc_0);
generator.Emit(OpCodes.Ldc_I4, iArgs);
generator.Emit(OpCodes.Ldarg, iArgs+1);
if(paramTypes[iArgs].IsByRef)
{
if(paramTypes[iArgs].GetElementType().IsValueType)
{
generator.Emit(OpCodes.Ldobj, paramTypes[iArgs].GetElementType());
generator.Emit(OpCodes.Box, paramTypes[iArgs].GetElementType());
}
else
generator.Emit(OpCodes.Ldind_Ref);
}
else
{
if(paramTypes[iArgs].IsValueType)
generator.Emit(OpCodes.Box, paramTypes[iArgs]);
}
generator.Emit(OpCodes.Stelem_Ref);
if(paramTypes[iArgs].IsByRef)
{
generator.Emit(OpCodes.Ldloc_2);
generator.Emit(OpCodes.Ldc_I4, iOutArgs);
generator.Emit(OpCodes.Ldc_I4, iArgs);
generator.Emit(OpCodes.Stelem_I4);
refArgs[iOutArgs] = iArgs;
for (int iArgs = 0, iInArgs = 0, iOutArgs = 0; iArgs < paramTypes.Length; iArgs++) {
generator.Emit (OpCodes.Ldloc_0);
generator.Emit (OpCodes.Ldc_I4, iArgs);
generator.Emit (OpCodes.Ldarg, iArgs + 1);
if (paramTypes [iArgs].IsByRef) {
if (paramTypes [iArgs].GetElementType ().IsValueType) {
generator.Emit (OpCodes.Ldobj, paramTypes [iArgs].GetElementType ());
generator.Emit (OpCodes.Box, paramTypes [iArgs].GetElementType ());
} else
generator.Emit (OpCodes.Ldind_Ref);
} else {
if (paramTypes [iArgs].IsValueType)
generator.Emit (OpCodes.Box, paramTypes [iArgs]);
}
generator.Emit (OpCodes.Stelem_Ref);
if (paramTypes [iArgs].IsByRef) {
generator.Emit (OpCodes.Ldloc_2);
generator.Emit (OpCodes.Ldc_I4, iOutArgs);
generator.Emit (OpCodes.Ldc_I4, iArgs);
generator.Emit (OpCodes.Stelem_I4);
refArgs [iOutArgs] = iArgs;
iOutArgs++;
}
if(paramInfo[iArgs].IsIn || (!paramInfo[iArgs].IsOut))
{
generator.Emit(OpCodes.Ldloc_1);
generator.Emit(OpCodes.Ldc_I4, iInArgs);
generator.Emit(OpCodes.Ldarg, iArgs+1);
if (paramInfo [iArgs].IsIn || (!paramInfo [iArgs].IsOut)) {
generator.Emit (OpCodes.Ldloc_1);
generator.Emit (OpCodes.Ldc_I4, iInArgs);
generator.Emit (OpCodes.Ldarg, iArgs + 1);
if(paramTypes[iArgs].IsByRef)
{
if(paramTypes[iArgs].GetElementType().IsValueType)
{
generator.Emit(OpCodes.Ldobj, paramTypes[iArgs].GetElementType());
generator.Emit(OpCodes.Box, paramTypes[iArgs].GetElementType());
}
else
generator.Emit(OpCodes.Ldind_Ref);
}
else
{
if(paramTypes[iArgs].IsValueType)
generator.Emit(OpCodes.Box, paramTypes[iArgs]);
if (paramTypes [iArgs].IsByRef) {
if (paramTypes [iArgs].GetElementType ().IsValueType) {
generator.Emit (OpCodes.Ldobj, paramTypes [iArgs].GetElementType ());
generator.Emit (OpCodes.Box, paramTypes [iArgs].GetElementType ());
} else
generator.Emit (OpCodes.Ldind_Ref);
} else {
if (paramTypes [iArgs].IsValueType)
generator.Emit (OpCodes.Box, paramTypes [iArgs]);
}
generator.Emit(OpCodes.Stelem_Ref);
generator.Emit (OpCodes.Stelem_Ref);
iInArgs++;
}
}
// Calls the callFunction method of the base class
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldloc_0);
generator.Emit(OpCodes.Ldloc_1);
generator.Emit(OpCodes.Ldloc_2);
var miGenericEventHandler = delegateParent.GetMethod("callFunction");
generator.Emit(OpCodes.Call, miGenericEventHandler);
generator.Emit (OpCodes.Ldarg_0);
generator.Emit (OpCodes.Ldloc_0);
generator.Emit (OpCodes.Ldloc_1);
generator.Emit (OpCodes.Ldloc_2);
var miGenericEventHandler = delegateParent.GetMethod ("callFunction");
generator.Emit (OpCodes.Call, miGenericEventHandler);
// Stores return value
if(returnType == typeof(void))
{
generator.Emit(OpCodes.Pop);
generator.Emit(OpCodes.Ldnull);
}
else if(returnType.IsValueType)
{
generator.Emit(OpCodes.Unbox, returnType);
generator.Emit(OpCodes.Ldobj, returnType);
}
else
generator.Emit(OpCodes.Castclass, returnType);
if (returnType == typeof(void)) {
generator.Emit (OpCodes.Pop);
generator.Emit (OpCodes.Ldnull);
} else if (returnType.IsValueType) {
generator.Emit (OpCodes.Unbox, returnType);
generator.Emit (OpCodes.Ldobj, returnType);
} else
generator.Emit (OpCodes.Castclass, returnType);
generator.Emit(OpCodes.Stloc_3);
generator.Emit (OpCodes.Stloc_3);
// Stores new value of out and ref params
for(int i = 0; i < refArgs.Length; i++)
{
generator.Emit(OpCodes.Ldarg, refArgs[i]+1);
generator.Emit(OpCodes.Ldloc_0);
generator.Emit(OpCodes.Ldc_I4, refArgs[i]);
generator.Emit(OpCodes.Ldelem_Ref);
for (int i = 0; i < refArgs.Length; i++) {
generator.Emit (OpCodes.Ldarg, refArgs [i] + 1);
generator.Emit (OpCodes.Ldloc_0);
generator.Emit (OpCodes.Ldc_I4, refArgs [i]);
generator.Emit (OpCodes.Ldelem_Ref);
if(paramTypes[refArgs[i]].GetElementType().IsValueType)
{
generator.Emit(OpCodes.Unbox, paramTypes[refArgs[i]].GetElementType());
generator.Emit(OpCodes.Ldobj, paramTypes[refArgs[i]].GetElementType());
generator.Emit(OpCodes.Stobj, paramTypes[refArgs[i]].GetElementType());
}
else
{
generator.Emit(OpCodes.Castclass, paramTypes[refArgs[i]].GetElementType());
generator.Emit(OpCodes.Stind_Ref);
if (paramTypes [refArgs [i]].GetElementType ().IsValueType) {
generator.Emit (OpCodes.Unbox, paramTypes [refArgs [i]].GetElementType ());
generator.Emit (OpCodes.Ldobj, paramTypes [refArgs [i]].GetElementType ());
generator.Emit (OpCodes.Stobj, paramTypes [refArgs [i]].GetElementType ());
} else {
generator.Emit (OpCodes.Castclass, paramTypes [refArgs [i]].GetElementType ());
generator.Emit (OpCodes.Stind_Ref);
}
}
// Returns
if(!(returnType == typeof(void)))
generator.Emit(OpCodes.Ldloc_3);
if (!(returnType == typeof(void)))
generator.Emit (OpCodes.Ldloc_3);
generator.Emit(OpCodes.Ret);
return myType.CreateType(); // creates the new type
generator.Emit (OpCodes.Ret);
return myType.CreateType (); // creates the new type
#endif
}
void GetReturnTypesFromClass (Type klass, out Type[][] returnTypes)
{
var classMethods = klass.GetMethods();
var classMethods = klass.GetMethods ();
returnTypes = new Type[classMethods.Length][];
int i = 0;
foreach(var method in classMethods)
{
if(klass.IsInterface)
{
GetReturnTypesFromMethod (method, out returnTypes[i]);
foreach (var method in classMethods) {
if (klass.IsInterface) {
GetReturnTypesFromMethod (method, out returnTypes [i]);
i++;
}
else
{
if(!method.IsPrivate && !method.IsFinal && method.IsVirtual) {
GetReturnTypesFromMethod (method, out returnTypes[i]);
} else {
if (!method.IsPrivate && !method.IsFinal && method.IsVirtual) {
GetReturnTypesFromMethod (method, out returnTypes [i]);
i++;
}
}
......@@ -336,110 +308,108 @@ namespace LuaInterface
* Generates an implementation of klass, if it is an interface, or
* a subclass of klass that delegates its virtual methods to a Lua table.
*/
public void GenerateClass(Type klass, out Type newType, out Type[][] returnTypes)
public void GenerateClass (Type klass, out Type newType, out Type[][] returnTypes)
{
#if MONOTOUCH
throw new NotImplementedException (" Emit not available on MonoTouch ");
#else
string typeName;
lock(this)
{
lock (this) {
typeName = "LuaGeneratedClass" + luaClassNumber;
luaClassNumber++;
}
TypeBuilder myType;
// Define a public class in the assembly, called typeName
if(klass.IsInterface)
myType = newModule.DefineType(typeName, TypeAttributes.Public, typeof(object), new Type[] { klass, typeof(ILuaGeneratedType) });
if (klass.IsInterface)
myType = newModule.DefineType (typeName, TypeAttributes.Public, typeof(object), new Type[] {
klass,
typeof(ILuaGeneratedType)
});
else
myType = newModule.DefineType(typeName, TypeAttributes.Public, klass, new Type[] { typeof(ILuaGeneratedType) });
myType = newModule.DefineType (typeName, TypeAttributes.Public, klass, new Type[] { typeof(ILuaGeneratedType) });
// Field that stores the Lua table
var luaTableField = myType.DefineField("__luaInterface_luaTable", typeof(LuaTable), FieldAttributes.Public);
var luaTableField = myType.DefineField ("__luaInterface_luaTable", typeof(LuaTable), FieldAttributes.Public);
// Field that stores the return types array
var returnTypesField = myType.DefineField("__luaInterface_returnTypes", typeof(Type[][]), FieldAttributes.Public);
var returnTypesField = myType.DefineField ("__luaInterface_returnTypes", typeof(Type[][]), FieldAttributes.Public);
// Generates the constructor for the new type, it takes a Lua table and an array
// of return types and stores them in the respective fields
var constructor = myType.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { typeof(LuaTable), typeof(Type[][]) });
ILGenerator generator = constructor.GetILGenerator();
generator.Emit(OpCodes.Ldarg_0);
if(klass.IsInterface)
generator.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));
var constructor = myType.DefineConstructor (MethodAttributes.Public, CallingConventions.Standard, new Type[] {
typeof(LuaTable),
typeof(Type[][])
});
ILGenerator generator = constructor.GetILGenerator ();
generator.Emit (OpCodes.Ldarg_0);
if (klass.IsInterface)
generator.Emit (OpCodes.Call, typeof(object).GetConstructor (Type.EmptyTypes));
else
generator.Emit(OpCodes.Call, klass.GetConstructor(Type.EmptyTypes));
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Stfld, luaTableField);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldarg_2);
generator.Emit(OpCodes.Stfld, returnTypesField);
generator.Emit(OpCodes.Ret);
generator.Emit (OpCodes.Call, klass.GetConstructor (Type.EmptyTypes));
generator.Emit (OpCodes.Ldarg_0);
generator.Emit (OpCodes.Ldarg_1);
generator.Emit (OpCodes.Stfld, luaTableField);
generator.Emit (OpCodes.Ldarg_0);
generator.Emit (OpCodes.Ldarg_2);
generator.Emit (OpCodes.Stfld, returnTypesField);
generator.Emit (OpCodes.Ret);
// Generates overriden versions of the klass' public virtual methods
var classMethods = klass.GetMethods();
var classMethods = klass.GetMethods ();
returnTypes = new Type[classMethods.Length][];
int i = 0;
foreach(var method in classMethods)
{
if(klass.IsInterface)
{
GenerateMethod(myType, method, MethodAttributes.HideBySig|MethodAttributes.Virtual|MethodAttributes.NewSlot,
i, luaTableField, returnTypesField, false, out returnTypes[i]);
foreach (var method in classMethods) {
if (klass.IsInterface) {
GenerateMethod (myType, method, MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.NewSlot,
i, luaTableField, returnTypesField, false, out returnTypes [i]);
i++;
}
else
{
if(!method.IsPrivate && !method.IsFinal && method.IsVirtual)
{
GenerateMethod(myType, method, (method.Attributes|MethodAttributes.NewSlot)^MethodAttributes.NewSlot, i,
luaTableField, returnTypesField, true, out returnTypes[i]);
} else {
if (!method.IsPrivate && !method.IsFinal && method.IsVirtual) {
GenerateMethod (myType, method, (method.Attributes | MethodAttributes.NewSlot) ^ MethodAttributes.NewSlot, i,
luaTableField, returnTypesField, true, out returnTypes [i]);
i++;
}
}
}
// Generates an implementation of the __luaInterface_getLuaTable method
var returnTableMethod = myType.DefineMethod("__luaInterface_getLuaTable",
var returnTableMethod = myType.DefineMethod ("__luaInterface_getLuaTable",
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual, typeof(LuaTable), new Type[0]);
myType.DefineMethodOverride(returnTableMethod, typeof(ILuaGeneratedType).GetMethod("__luaInterface_getLuaTable"));
generator = returnTableMethod.GetILGenerator();
generator.Emit(OpCodes.Ldfld, luaTableField);
generator.Emit(OpCodes.Ret);
newType = myType.CreateType(); // Creates the type
myType.DefineMethodOverride (returnTableMethod, typeof(ILuaGeneratedType).GetMethod ("__luaInterface_getLuaTable"));
generator = returnTableMethod.GetILGenerator ();
generator.Emit (OpCodes.Ldfld, luaTableField);
generator.Emit (OpCodes.Ret);
newType = myType.CreateType (); // Creates the type
#endif
}
void GetReturnTypesFromMethod (MethodInfo method, out Type[] returnTypes)
{
var paramInfo = method.GetParameters();
var paramInfo = method.GetParameters ();
var paramTypes = new Type[paramInfo.Length];
var returnTypesList = new List<Type>();
var returnTypesList = new List<Type> ();
// Counts out and ref parameters, for later use,
// and creates the list of return types
int nOutParams = 0;
int nOutAndRefParams = 0;
var returnType = method.ReturnType;
returnTypesList.Add(returnType);
returnTypesList.Add (returnType);
for(int i = 0; i < paramTypes.Length; i++)
{
paramTypes[i] = paramInfo[i].ParameterType;
if((!paramInfo[i].IsIn) && paramInfo[i].IsOut)
for (int i = 0; i < paramTypes.Length; i++) {
paramTypes [i] = paramInfo [i].ParameterType;
if ((!paramInfo [i].IsIn) && paramInfo [i].IsOut)
nOutParams++;
if(paramTypes[i].IsByRef)
{
returnTypesList.Add(paramTypes[i].GetElementType());
if (paramTypes [i].IsByRef) {
returnTypesList.Add (paramTypes [i].GetElementType ());
nOutAndRefParams++;
}
}
int[] refArgs = new int[nOutAndRefParams];
returnTypes = returnTypesList.ToArray();
returnTypes = returnTypesList.ToArray ();
}
#if !MONOTOUCH
......@@ -450,261 +420,234 @@ namespace LuaInterface
* doesn't the method calls the base method (or does nothing, in case of interface
* implementations).
*/
private void GenerateMethod(TypeBuilder myType, MethodInfo method, MethodAttributes attributes, int methodIndex,
private void GenerateMethod (TypeBuilder myType, MethodInfo method, MethodAttributes attributes, int methodIndex,
FieldInfo luaTableField, FieldInfo returnTypesField, bool generateBase, out Type[] returnTypes)
{
var paramInfo = method.GetParameters();
var paramInfo = method.GetParameters ();
var paramTypes = new Type[paramInfo.Length];
var returnTypesList = new List<Type>();
var returnTypesList = new List<Type> ();
// Counts out and ref parameters, for later use,
// and creates the list of return types
int nOutParams = 0;
int nOutAndRefParams = 0;
var returnType = method.ReturnType;
returnTypesList.Add(returnType);
returnTypesList.Add (returnType);
for(int i = 0; i < paramTypes.Length; i++)
{
paramTypes[i] = paramInfo[i].ParameterType;
if((!paramInfo[i].IsIn) && paramInfo[i].IsOut)
for (int i = 0; i < paramTypes.Length; i++) {
paramTypes [i] = paramInfo [i].ParameterType;
if ((!paramInfo [i].IsIn) && paramInfo [i].IsOut)
nOutParams++;
if(paramTypes[i].IsByRef)
{
returnTypesList.Add(paramTypes[i].GetElementType());
if (paramTypes [i].IsByRef) {
returnTypesList.Add (paramTypes [i].GetElementType ());
nOutAndRefParams++;
}
}
int[] refArgs = new int[nOutAndRefParams];
returnTypes = returnTypesList.ToArray();
returnTypes = returnTypesList.ToArray ();
// Generates a version of the method that calls the base implementation
// directly, for use by the base field of the table
if(generateBase)
{
var baseMethod = myType.DefineMethod("__luaInterface_base_"+method.Name,
MethodAttributes.Private|MethodAttributes.NewSlot|MethodAttributes.HideBySig,
if (generateBase) {
var baseMethod = myType.DefineMethod ("__luaInterface_base_" + method.Name,
MethodAttributes.Private | MethodAttributes.NewSlot | MethodAttributes.HideBySig,
returnType, paramTypes);
ILGenerator generatorBase = baseMethod.GetILGenerator();
generatorBase.Emit(OpCodes.Ldarg_0);
ILGenerator generatorBase = baseMethod.GetILGenerator ();
generatorBase.Emit (OpCodes.Ldarg_0);
for(int i = 0; i < paramTypes.Length; i++)
generatorBase.Emit(OpCodes.Ldarg, i+1);
for (int i = 0; i < paramTypes.Length; i++)
generatorBase.Emit (OpCodes.Ldarg, i + 1);
generatorBase.Emit(OpCodes.Call, method);
generatorBase.Emit (OpCodes.Call, method);
if(returnType == typeof(void))
generatorBase.Emit(OpCodes.Pop);
if (returnType == typeof(void))
generatorBase.Emit (OpCodes.Pop);
generatorBase.Emit(OpCodes.Ret);
generatorBase.Emit (OpCodes.Ret);
}
// Defines the method
var methodImpl = myType.DefineMethod(method.Name, attributes, returnType, paramTypes);
var methodImpl = myType.DefineMethod (method.Name, attributes, returnType, paramTypes);
// If it's an implementation of an interface tells what method it
// is overriding
if(myType.BaseType.Equals(typeof(object)))
myType.DefineMethodOverride(methodImpl, method);
if (myType.BaseType.Equals (typeof(object)))
myType.DefineMethodOverride (methodImpl, method);
ILGenerator generator = methodImpl.GetILGenerator( );
generator.DeclareLocal(typeof(object[])); // original arguments
generator.DeclareLocal(typeof(object[])); // with out-only arguments removed
generator.DeclareLocal(typeof(int[])); // indexes of out and ref arguments
ILGenerator generator = methodImpl.GetILGenerator ();
generator.DeclareLocal (typeof(object[])); // original arguments
generator.DeclareLocal (typeof(object[])); // with out-only arguments removed
generator.DeclareLocal (typeof(int[])); // indexes of out and ref arguments
if(!(returnType == typeof(void))) // return value
generator.DeclareLocal(returnType);
if (!(returnType == typeof(void))) // return value
generator.DeclareLocal (returnType);
else
generator.DeclareLocal(typeof(object));
generator.DeclareLocal (typeof(object));
// Initializes local variables
generator.Emit(OpCodes.Ldc_I4, paramTypes.Length);
generator.Emit(OpCodes.Newarr, typeof(object));
generator.Emit(OpCodes.Stloc_0);
generator.Emit(OpCodes.Ldc_I4, paramTypes.Length-nOutParams+1);
generator.Emit(OpCodes.Newarr, typeof(object));
generator.Emit(OpCodes.Stloc_1);
generator.Emit(OpCodes.Ldc_I4, nOutAndRefParams);
generator.Emit(OpCodes.Newarr, typeof(int));
generator.Emit(OpCodes.Stloc_2);
generator.Emit(OpCodes.Ldloc_1);
generator.Emit(OpCodes.Ldc_I4_0);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldfld, luaTableField);
generator.Emit(OpCodes.Stelem_Ref);
generator.Emit (OpCodes.Ldc_I4, paramTypes.Length);
generator.Emit (OpCodes.Newarr, typeof(object));
generator.Emit (OpCodes.Stloc_0);
generator.Emit (OpCodes.Ldc_I4, paramTypes.Length - nOutParams + 1);
generator.Emit (OpCodes.Newarr, typeof(object));
generator.Emit (OpCodes.Stloc_1);
generator.Emit (OpCodes.Ldc_I4, nOutAndRefParams);
generator.Emit (OpCodes.Newarr, typeof(int));
generator.Emit (OpCodes.Stloc_2);
generator.Emit (OpCodes.Ldloc_1);
generator.Emit (OpCodes.Ldc_I4_0);
generator.Emit (OpCodes.Ldarg_0);
generator.Emit (OpCodes.Ldfld, luaTableField);
generator.Emit (OpCodes.Stelem_Ref);
// Stores the arguments into the local variables, as needed
for(int iArgs = 0, iInArgs = 1, iOutArgs = 0; iArgs < paramTypes.Length; iArgs++)
{
generator.Emit(OpCodes.Ldloc_0);
generator.Emit(OpCodes.Ldc_I4, iArgs);
generator.Emit(OpCodes.Ldarg, iArgs+1);
if(paramTypes[iArgs].IsByRef)
{
if(paramTypes[iArgs].GetElementType().IsValueType)
{
generator.Emit(OpCodes.Ldobj, paramTypes[iArgs].GetElementType());
generator.Emit(OpCodes.Box, paramTypes[iArgs].GetElementType());
}
else
generator.Emit(OpCodes.Ldind_Ref);
}
else
{
if(paramTypes[iArgs].IsValueType)
generator.Emit(OpCodes.Box, paramTypes[iArgs]);
}
generator.Emit(OpCodes.Stelem_Ref);
if(paramTypes[iArgs].IsByRef)
{
generator.Emit(OpCodes.Ldloc_2);
generator.Emit(OpCodes.Ldc_I4, iOutArgs);
generator.Emit(OpCodes.Ldc_I4, iArgs);
generator.Emit(OpCodes.Stelem_I4);
refArgs[iOutArgs] = iArgs;
for (int iArgs = 0, iInArgs = 1, iOutArgs = 0; iArgs < paramTypes.Length; iArgs++) {
generator.Emit (OpCodes.Ldloc_0);
generator.Emit (OpCodes.Ldc_I4, iArgs);
generator.Emit (OpCodes.Ldarg, iArgs + 1);
if (paramTypes [iArgs].IsByRef) {
if (paramTypes [iArgs].GetElementType ().IsValueType) {
generator.Emit (OpCodes.Ldobj, paramTypes [iArgs].GetElementType ());
generator.Emit (OpCodes.Box, paramTypes [iArgs].GetElementType ());
} else
generator.Emit (OpCodes.Ldind_Ref);
} else {
if (paramTypes [iArgs].IsValueType)
generator.Emit (OpCodes.Box, paramTypes [iArgs]);
}
generator.Emit (OpCodes.Stelem_Ref);
if (paramTypes [iArgs].IsByRef) {
generator.Emit (OpCodes.Ldloc_2);
generator.Emit (OpCodes.Ldc_I4, iOutArgs);
generator.Emit (OpCodes.Ldc_I4, iArgs);
generator.Emit (OpCodes.Stelem_I4);
refArgs [iOutArgs] = iArgs;
iOutArgs++;
}
if(paramInfo[iArgs].IsIn || (!paramInfo[iArgs].IsOut))
{
generator.Emit(OpCodes.Ldloc_1);
generator.Emit(OpCodes.Ldc_I4, iInArgs);
generator.Emit(OpCodes.Ldarg, iArgs+1);
if (paramInfo [iArgs].IsIn || (!paramInfo [iArgs].IsOut)) {
generator.Emit (OpCodes.Ldloc_1);
generator.Emit (OpCodes.Ldc_I4, iInArgs);
generator.Emit (OpCodes.Ldarg, iArgs + 1);
if(paramTypes[iArgs].IsByRef)
{
if(paramTypes[iArgs].GetElementType().IsValueType)
{
generator.Emit(OpCodes.Ldobj, paramTypes[iArgs].GetElementType());
generator.Emit(OpCodes.Box, paramTypes[iArgs].GetElementType());
}
else
generator.Emit(OpCodes.Ldind_Ref);
}
else
{
if(paramTypes[iArgs].IsValueType)
generator.Emit(OpCodes.Box, paramTypes[iArgs]);
if (paramTypes [iArgs].IsByRef) {
if (paramTypes [iArgs].GetElementType ().IsValueType) {
generator.Emit (OpCodes.Ldobj, paramTypes [iArgs].GetElementType ());
generator.Emit (OpCodes.Box, paramTypes [iArgs].GetElementType ());
} else
generator.Emit (OpCodes.Ldind_Ref);
} else {
if (paramTypes [iArgs].IsValueType)
generator.Emit (OpCodes.Box, paramTypes [iArgs]);
}
generator.Emit(OpCodes.Stelem_Ref);
generator.Emit (OpCodes.Stelem_Ref);
iInArgs++;
}
}
// Gets the function the method will delegate to by calling
// the getTableFunction method of class LuaClassHelper
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldfld, luaTableField);
generator.Emit(OpCodes.Ldstr, method.Name);
generator.Emit(OpCodes.Call, classHelper.GetMethod("getTableFunction"));
var lab1 = generator.DefineLabel();
generator.Emit(OpCodes.Dup);
generator.Emit(OpCodes.Brtrue_S, lab1);
generator.Emit (OpCodes.Ldarg_0);
generator.Emit (OpCodes.Ldfld, luaTableField);
generator.Emit (OpCodes.Ldstr, method.Name);
generator.Emit (OpCodes.Call, classHelper.GetMethod ("getTableFunction"));
var lab1 = generator.DefineLabel ();
generator.Emit (OpCodes.Dup);
generator.Emit (OpCodes.Brtrue_S, lab1);
// Function does not exist, call base method
generator.Emit(OpCodes.Pop);
generator.Emit (OpCodes.Pop);
if(!method.IsAbstract)
{
generator.Emit(OpCodes.Ldarg_0);
if (!method.IsAbstract) {
generator.Emit (OpCodes.Ldarg_0);
for(int i = 0; i < paramTypes.Length; i++)
generator.Emit(OpCodes.Ldarg, i+1);
for (int i = 0; i < paramTypes.Length; i++)
generator.Emit (OpCodes.Ldarg, i + 1);
generator.Emit(OpCodes.Call, method);
generator.Emit (OpCodes.Call, method);
if(returnType == typeof(void))
generator.Emit(OpCodes.Pop);
if (returnType == typeof(void))
generator.Emit (OpCodes.Pop);
generator.Emit(OpCodes.Ret);
generator.Emit(OpCodes.Ldnull);
}
else
generator.Emit(OpCodes.Ldnull);
generator.Emit (OpCodes.Ret);
generator.Emit (OpCodes.Ldnull);
} else
generator.Emit (OpCodes.Ldnull);
var lab2 = generator.DefineLabel();
generator.Emit(OpCodes.Br_S, lab2);
generator.MarkLabel(lab1);
var lab2 = generator.DefineLabel ();
generator.Emit (OpCodes.Br_S, lab2);
generator.MarkLabel (lab1);
// Function exists, call using method callFunction of LuaClassHelper
generator.Emit(OpCodes.Ldloc_0);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldfld, returnTypesField);
generator.Emit(OpCodes.Ldc_I4, methodIndex);
generator.Emit(OpCodes.Ldelem_Ref);
generator.Emit(OpCodes.Ldloc_1);
generator.Emit(OpCodes.Ldloc_2);
generator.Emit(OpCodes.Call, classHelper.GetMethod("callFunction"));
generator.MarkLabel(lab2);
generator.Emit (OpCodes.Ldloc_0);
generator.Emit (OpCodes.Ldarg_0);
generator.Emit (OpCodes.Ldfld, returnTypesField);
generator.Emit (OpCodes.Ldc_I4, methodIndex);
generator.Emit (OpCodes.Ldelem_Ref);
generator.Emit (OpCodes.Ldloc_1);
generator.Emit (OpCodes.Ldloc_2);
generator.Emit (OpCodes.Call, classHelper.GetMethod ("callFunction"));
generator.MarkLabel (lab2);
// Stores the function return value
if(returnType == typeof(void))
{
generator.Emit(OpCodes.Pop);
generator.Emit(OpCodes.Ldnull);
}
else if(returnType.IsValueType)
{
generator.Emit(OpCodes.Unbox, returnType);
generator.Emit(OpCodes.Ldobj, returnType);
}
else
generator.Emit(OpCodes.Castclass, returnType);
if (returnType == typeof(void)) {
generator.Emit (OpCodes.Pop);
generator.Emit (OpCodes.Ldnull);
} else if (returnType.IsValueType) {
generator.Emit (OpCodes.Unbox, returnType);
generator.Emit (OpCodes.Ldobj, returnType);
} else
generator.Emit (OpCodes.Castclass, returnType);
generator.Emit(OpCodes.Stloc_3);
generator.Emit (OpCodes.Stloc_3);
// Sets return values of out and ref parameters
for(int i = 0; i < refArgs.Length; i++)
{
generator.Emit(OpCodes.Ldarg, refArgs[i]+1);
generator.Emit(OpCodes.Ldloc_0);
generator.Emit(OpCodes.Ldc_I4, refArgs[i]);
generator.Emit(OpCodes.Ldelem_Ref);
for (int i = 0; i < refArgs.Length; i++) {
generator.Emit (OpCodes.Ldarg, refArgs [i] + 1);
generator.Emit (OpCodes.Ldloc_0);
generator.Emit (OpCodes.Ldc_I4, refArgs [i]);
generator.Emit (OpCodes.Ldelem_Ref);
if(paramTypes[refArgs[i]].GetElementType().IsValueType)
{
generator.Emit(OpCodes.Unbox, paramTypes[refArgs[i]].GetElementType());
generator.Emit(OpCodes.Ldobj, paramTypes[refArgs[i]].GetElementType());
generator.Emit(OpCodes.Stobj, paramTypes[refArgs[i]].GetElementType());
}
else
{
generator.Emit(OpCodes.Castclass, paramTypes[refArgs[i]].GetElementType());
generator.Emit(OpCodes.Stind_Ref);
if (paramTypes [refArgs [i]].GetElementType ().IsValueType) {
generator.Emit (OpCodes.Unbox, paramTypes [refArgs [i]].GetElementType ());
generator.Emit (OpCodes.Ldobj, paramTypes [refArgs [i]].GetElementType ());
generator.Emit (OpCodes.Stobj, paramTypes [refArgs [i]].GetElementType ());
} else {
generator.Emit (OpCodes.Castclass, paramTypes [refArgs [i]].GetElementType ());
generator.Emit (OpCodes.Stind_Ref);
}
}
// Returns
if(!(returnType == typeof(void)))
generator.Emit(OpCodes.Ldloc_3);
if (!(returnType == typeof(void)))
generator.Emit (OpCodes.Ldloc_3);
generator.Emit(OpCodes.Ret);
generator.Emit (OpCodes.Ret);
}
#endif
/*
* Gets an event handler for the event type that delegates to the eventHandler Lua function.
* Caches the generated type.
*/
public LuaEventHandler GetEvent(Type eventHandlerType, LuaFunction eventHandler)
public LuaEventHandler GetEvent (Type eventHandlerType, LuaFunction eventHandler)
{
#if MONOTOUCH
throw new NotImplementedException (" Emit not available on MonoTouch ");
#else
Type eventConsumerType;
if(eventHandlerCollection.ContainsKey(eventHandlerType))
eventConsumerType = eventHandlerCollection[eventHandlerType];
else
{
eventConsumerType = GenerateEvent(eventHandlerType);
eventHandlerCollection[eventHandlerType] = eventConsumerType;
if (eventHandlerCollection.ContainsKey (eventHandlerType))
eventConsumerType = eventHandlerCollection [eventHandlerType];
else {
eventConsumerType = GenerateEvent (eventHandlerType);
eventHandlerCollection [eventHandlerType] = eventConsumerType;
}
var luaEventHandler = (LuaEventHandler)Activator.CreateInstance(eventConsumerType);
var luaEventHandler = (LuaEventHandler)Activator.CreateInstance (eventConsumerType);
luaEventHandler.handler = eventHandler;
return luaEventHandler;
#endif
......@@ -712,47 +655,45 @@ namespace LuaInterface
public void RegisterLuaDelegateType (Type delegateType, Type luaDelegateType)
{
delegateCollection[delegateType] = luaDelegateType;
delegateCollection [delegateType] = luaDelegateType;
}
public void RegisterLuaClassType (Type klass, Type luaClass)
{
LuaClassType luaClassType = new LuaClassType();
LuaClassType luaClassType = new LuaClassType ();
luaClassType.klass = luaClass;
GetReturnTypesFromClass (klass, out luaClassType.returnTypes);
classCollection[klass] = luaClassType;
classCollection [klass] = luaClassType;
}
/*
* Gets a delegate with delegateType that calls the luaFunc Lua function
* Caches the generated type.
*/
public Delegate GetDelegate(Type delegateType, LuaFunction luaFunc)
public Delegate GetDelegate (Type delegateType, LuaFunction luaFunc)
{
var returnTypes = new List<Type>();
var returnTypes = new List<Type> ();
Type luaDelegateType;
if(delegateCollection.ContainsKey(delegateType))
luaDelegateType = delegateCollection[delegateType];
else
{
luaDelegateType = GenerateDelegate(delegateType);
delegateCollection[delegateType] = luaDelegateType;
if (delegateCollection.ContainsKey (delegateType))
luaDelegateType = delegateCollection [delegateType];
else {
luaDelegateType = GenerateDelegate (delegateType);
delegateCollection [delegateType] = luaDelegateType;
}
var methodInfo = delegateType.GetMethod("Invoke");
returnTypes.Add(methodInfo.ReturnType);
var methodInfo = delegateType.GetMethod ("Invoke");
returnTypes.Add (methodInfo.ReturnType);
foreach(ParameterInfo paramInfo in methodInfo.GetParameters())
{
if(paramInfo.ParameterType.IsByRef)
returnTypes.Add(paramInfo.ParameterType);
foreach (ParameterInfo paramInfo in methodInfo.GetParameters()) {
if (paramInfo.ParameterType.IsByRef)
returnTypes.Add (paramInfo.ParameterType);
}
var luaDelegate = (LuaDelegate)Activator.CreateInstance(luaDelegateType);
var luaDelegate = (LuaDelegate)Activator.CreateInstance (luaDelegateType);
luaDelegate.function = luaFunc;
luaDelegate.returnTypes = returnTypes.ToArray();
luaDelegate.returnTypes = returnTypes.ToArray ();
return Delegate.CreateDelegate(delegateType, luaDelegate, "CallFunction");
return Delegate.CreateDelegate (delegateType, luaDelegate, "CallFunction");
}
/*
......@@ -761,20 +702,22 @@ namespace LuaInterface
* luaTable table.
* Caches the generated type.
*/
public object GetClassInstance(Type klass, LuaTable luaTable)
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);
classCollection[klass] = luaClassType;
if (classCollection.ContainsKey (klass))
luaClassType = classCollection [klass];
else {
luaClassType = new LuaClassType ();
GenerateClass (klass, out luaClassType.klass, out luaClassType.returnTypes);
classCollection [klass] = luaClassType;
}
return Activator.CreateInstance(luaClassType.klass, new object[] {luaTable, luaClassType.returnTypes});
return Activator.CreateInstance (luaClassType.klass, new object[] {
luaTable,
luaClassType.returnTypes
});
}
}
}
\ No newline at end of file
......@@ -22,7 +22,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
namespace LuaInterface
......@@ -39,15 +38,15 @@ namespace LuaInterface
private ObjectTranslator translator;
private Type delegateType;
public DelegateGenerator(ObjectTranslator translator, Type delegateType)
public DelegateGenerator (ObjectTranslator translator, Type delegateType)
{
this.translator = translator;
this.delegateType = delegateType;
}
public object extractGenerated(KopiLua.Lua.lua_State luaState, int stackPos)
public object extractGenerated (KopiLua.Lua.lua_State luaState, int stackPos)
{
return CodeGeneration.Instance.GetDelegate(delegateType, translator.getFunction(luaState, stackPos));
return CodeGeneration.Instance.GetDelegate (delegateType, translator.getFunction (luaState, stackPos));
}
}
}
\ No newline at end of file
......@@ -22,7 +22,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
namespace LuaInterface
......@@ -33,6 +32,6 @@ namespace LuaInterface
*/
public interface ILuaGeneratedType
{
LuaTable __luaInterface_getLuaTable();
LuaTable __luaInterface_getLuaTable ();
}
}
\ No newline at end of file
......@@ -22,7 +22,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
namespace LuaInterface
......
......@@ -22,7 +22,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
using System.IO;
using System.Threading;
......@@ -74,7 +73,7 @@ namespace LuaInterface
private LuaCore.lua_Hook hookCallback = null;
#endregion
#region Globals auto-complete
private readonly List<string> globals = new List<string>();
private readonly List<string> globals = new List<string> ();
private bool globalsSorted;
#endregion
private /*readonly */ LuaCore.lua_State luaState;
......@@ -82,6 +81,7 @@ namespace LuaInterface
/// True while a script is being executed
/// </summary>
public bool IsExecuting { get { return executing; } }
private LuaCore.lua_CFunction panicCallback;
private ObjectTranslator translator;
/// <summary>
......@@ -90,7 +90,6 @@ namespace LuaInterface
//private object luaLock = new object();
private bool _StatePassed;
private bool executing;
static string init_luanet =
"local metatable = {} \n" +
"local import_type = luanet.import_type \n" +
......@@ -136,14 +135,11 @@ namespace LuaInterface
/// An alphabetically sorted list of all globals (objects, methods, etc.) externally added to this Lua instance
/// </summary>
/// <remarks>Members of globals are also listed. The formatting is optimized for text input auto-completion.</remarks>
public IEnumerable<string> Globals
{
get
{
public IEnumerable<string> Globals {
get {
// Only sort list when necessary
if(!globalsSorted)
{
globals.Sort();
if (!globalsSorted) {
globals.Sort ();
globalsSorted = true;
}
......@@ -152,29 +148,29 @@ namespace LuaInterface
}
#endregion
public Lua()
public Lua ()
{
luaState = LuaLib.luaL_newstate(); // steffenj: Lua 5.1.1 API change (lua_open is gone)
luaState = LuaLib.luaL_newstate (); // steffenj: Lua 5.1.1 API change (lua_open is gone)
//LuaLib.luaopen_base(luaState); // steffenj: luaopen_* no longer used
LuaLib.luaL_openlibs(luaState); // steffenj: Lua 5.1.1 API change (luaopen_base is gone, just open all libs right here)
LuaLib.lua_pushstring(luaState, "LUAINTERFACE LOADED");
LuaLib.lua_pushboolean(luaState, true);
LuaLib.lua_settable(luaState, (int)LuaIndexes.Registry);
LuaLib.lua_newtable(luaState);
LuaLib.lua_setglobal(luaState, "luanet");
LuaLib.lua_pushvalue(luaState, (int)LuaIndexes.Globals);
LuaLib.lua_getglobal(luaState, "luanet");
LuaLib.lua_pushstring(luaState, "getmetatable");
LuaLib.lua_getglobal(luaState, "getmetatable");
LuaLib.lua_settable(luaState, -3);
LuaLib.lua_replace(luaState, (int)LuaIndexes.Globals);
translator = new ObjectTranslator(this, luaState);
LuaLib.lua_replace(luaState, (int)LuaIndexes.Globals);
LuaLib.luaL_dostring(luaState, Lua.init_luanet); // steffenj: lua_dostring renamed to luaL_dostring
LuaLib.luaL_openlibs (luaState); // steffenj: Lua 5.1.1 API change (luaopen_base is gone, just open all libs right here)
LuaLib.lua_pushstring (luaState, "LUAINTERFACE LOADED");
LuaLib.lua_pushboolean (luaState, true);
LuaLib.lua_settable (luaState, (int)LuaIndexes.Registry);
LuaLib.lua_newtable (luaState);
LuaLib.lua_setglobal (luaState, "luanet");
LuaLib.lua_pushvalue (luaState, (int)LuaIndexes.Globals);
LuaLib.lua_getglobal (luaState, "luanet");
LuaLib.lua_pushstring (luaState, "getmetatable");
LuaLib.lua_getglobal (luaState, "getmetatable");
LuaLib.lua_settable (luaState, -3);
LuaLib.lua_replace (luaState, (int)LuaIndexes.Globals);
translator = new ObjectTranslator (this, luaState);
LuaLib.lua_replace (luaState, (int)LuaIndexes.Globals);
LuaLib.luaL_dostring (luaState, Lua.init_luanet); // steffenj: lua_dostring renamed to luaL_dostring
// We need to keep this in a managed reference so the delegate doesn't get garbage collected
panicCallback = new LuaCore.lua_CFunction(PanicCallback);
LuaLib.lua_atpanic(luaState, panicCallback);
panicCallback = new LuaCore.lua_CFunction (PanicCallback);
LuaLib.lua_atpanic (luaState, panicCallback);
//LuaLib.lua_atlock(luaState, lockCallback = new LuaCore.lua_CFunction(LockCallback));
//LuaLib.lua_atunlock(luaState, unlockCallback = new LuaCore.lua_CFunction(UnlockCallback));
......@@ -183,32 +179,29 @@ namespace LuaInterface
/*
* CAUTION: LuaInterface.Lua instances can't share the same lua state!
*/
public Lua(LuaCore.lua_State lState)
{
LuaLib.lua_pushstring(lState, "LUAINTERFACE LOADED");
LuaLib.lua_gettable(lState, (int)LuaIndexes.Registry);
if(LuaLib.lua_toboolean(lState, -1))
{
LuaLib.lua_settop(lState, -2);
throw new LuaException("There is already a LuaInterface.Lua instance associated with this Lua state");
}
else
{
LuaLib.lua_settop(lState, -2);
LuaLib.lua_pushstring(lState, "LUAINTERFACE LOADED");
LuaLib.lua_pushboolean(lState, true);
LuaLib.lua_settable(lState, (int)LuaIndexes.Registry);
public Lua (LuaCore.lua_State lState)
{
LuaLib.lua_pushstring (lState, "LUAINTERFACE LOADED");
LuaLib.lua_gettable (lState, (int)LuaIndexes.Registry);
if (LuaLib.lua_toboolean (lState, -1)) {
LuaLib.lua_settop (lState, -2);
throw new LuaException ("There is already a LuaInterface.Lua instance associated with this Lua state");
} else {
LuaLib.lua_settop (lState, -2);
LuaLib.lua_pushstring (lState, "LUAINTERFACE LOADED");
LuaLib.lua_pushboolean (lState, true);
LuaLib.lua_settable (lState, (int)LuaIndexes.Registry);
luaState = lState;
LuaLib.lua_pushvalue(lState, (int)LuaIndexes.Globals);
LuaLib.lua_getglobal(lState, "luanet");
LuaLib.lua_pushstring(lState, "getmetatable");
LuaLib.lua_getglobal(lState, "getmetatable");
LuaLib.lua_settable(lState, -3);
LuaLib.lua_replace(lState, (int)LuaIndexes.Globals);
translator = new ObjectTranslator(this, luaState);
LuaLib.lua_replace(lState, (int)LuaIndexes.Globals);
LuaLib.luaL_dostring(lState, Lua.init_luanet); // steffenj: lua_dostring renamed to luaL_dostring
LuaLib.lua_pushvalue (lState, (int)LuaIndexes.Globals);
LuaLib.lua_getglobal (lState, "luanet");
LuaLib.lua_pushstring (lState, "getmetatable");
LuaLib.lua_getglobal (lState, "getmetatable");
LuaLib.lua_settable (lState, -3);
LuaLib.lua_replace (lState, (int)LuaIndexes.Globals);
translator = new ObjectTranslator (this, luaState);
LuaLib.lua_replace (lState, (int)LuaIndexes.Globals);
LuaLib.luaL_dostring (lState, Lua.init_luanet); // steffenj: lua_dostring renamed to luaL_dostring
}
_StatePassed = true;
......@@ -236,45 +229,45 @@ namespace LuaInterface
return 0;
}*/
public void Close()
public void Close ()
{
if(_StatePassed)
if (_StatePassed)
return;
////// if(luaState != LuaCore.lua_State.Zero)
if(!luaState.IsNull())
LuaCore.lua_close(luaState);
if (!luaState.IsNull ())
LuaCore.lua_close (luaState);
//luaState = LuaCore.lua_State.Zero; <- suggested by Christopher Cebulski http://luaforge.net/forum/forum.php?thread_id = 44593&forum_id = 146
}
static int PanicCallback(LuaCore.lua_State luaState)
static int PanicCallback (LuaCore.lua_State luaState)
{
// string desc = LuaLib.lua_tostring(luaState, 1);
string reason = string.Format("unprotected error in call to Lua API ({0})", LuaLib.lua_tostring(luaState, -1));
string reason = string.Format ("unprotected error in call to Lua API ({0})", LuaLib.lua_tostring (luaState, -1));
// lua_tostring(L, -1);
throw new LuaException(reason);
throw new LuaException (reason);
}
/// <summary>
/// Assuming we have a Lua error string sitting on the stack, throw a C# exception out to the user's app
/// </summary>
/// <exception cref = "LuaScriptException">Thrown if the script caused an exception</exception>
private void ThrowExceptionFromError(int oldTop)
private void ThrowExceptionFromError (int oldTop)
{
object err = translator.getObject(luaState, -1);
LuaLib.lua_settop(luaState, oldTop);
object err = translator.getObject (luaState, -1);
LuaLib.lua_settop (luaState, oldTop);
// A pre-wrapped exception - just rethrow it (stack trace of InnerException will be preserved)
var luaEx = err as LuaScriptException;
if(!luaEx.IsNull())
if (!luaEx.IsNull ())
throw luaEx;
// A non-wrapped Lua error (best interpreted as a string) - wrap it and throw it
if(err.IsNull())
if (err.IsNull ())
err = "Unknown Lua Error";
throw new LuaScriptException(err.ToString(), string.Empty);
throw new LuaScriptException (err.ToString (), string.Empty);
}
/// <summary>
......@@ -282,17 +275,15 @@ namespace LuaInterface
/// </summary>
/// <returns>num of things on stack</returns>
/// <param name = "e">null for no pending exception</param>
internal int SetPendingException(Exception e)
internal int SetPendingException (Exception e)
{
var caughtExcept = e;
if(!caughtExcept.IsNull())
{
translator.throwError(luaState, caughtExcept);
LuaLib.lua_pushnil(luaState);
if (!caughtExcept.IsNull ()) {
translator.throwError (luaState, caughtExcept);
LuaLib.lua_pushnil (luaState);
return 1;
}
else
} else
return 0;
}
......@@ -302,23 +293,20 @@ namespace LuaInterface
/// <param name = "chunk"></param>
/// <param name = "name"></param>
/// <returns></returns>
public LuaFunction LoadString(string chunk, string name)
public LuaFunction LoadString (string chunk, string name)
{
int oldTop = LuaLib.lua_gettop(luaState);
int oldTop = LuaLib.lua_gettop (luaState);
executing = true;
try
{
if(LuaLib.luaL_loadbuffer(luaState, chunk, name) != 0)
ThrowExceptionFromError(oldTop);
}
finally
{
try {
if (LuaLib.luaL_loadbuffer (luaState, chunk, name) != 0)
ThrowExceptionFromError (oldTop);
} finally {
executing = false;
}
var result = translator.getFunction(luaState, -1);
translator.popValues(luaState, oldTop);
var result = translator.getFunction (luaState, -1);
translator.popValues (luaState, oldTop);
return result;
}
......@@ -327,15 +315,15 @@ namespace LuaInterface
/// </summary>
/// <param name = "fileName"></param>
/// <returns></returns>
public LuaFunction LoadFile(string fileName)
public LuaFunction LoadFile (string fileName)
{
int oldTop = LuaLib.lua_gettop(luaState);
int oldTop = LuaLib.lua_gettop (luaState);
if(LuaLib.luaL_loadfile(luaState, fileName) != 0)
ThrowExceptionFromError(oldTop);
if (LuaLib.luaL_loadfile (luaState, fileName) != 0)
ThrowExceptionFromError (oldTop);
var result = translator.getFunction(luaState, -1);
translator.popValues(luaState, oldTop);
var result = translator.getFunction (luaState, -1);
translator.popValues (luaState, oldTop);
return result;
}
......@@ -343,28 +331,23 @@ namespace LuaInterface
* Excutes a Lua chunk and returns all the chunk's return
* values in an array
*/
public object[] DoString(string chunk)
public object[] DoString (string chunk)
{
int oldTop = LuaLib.lua_gettop(luaState);
int oldTop = LuaLib.lua_gettop (luaState);
if(LuaLib.luaL_loadbuffer(luaState, chunk, "chunk") == 0)
{
if (LuaLib.luaL_loadbuffer (luaState, chunk, "chunk") == 0) {
executing = true;
try
{
if(LuaLib.lua_pcall(luaState, 0, -1, 0) == 0)
return translator.popValues(luaState, oldTop);
try {
if (LuaLib.lua_pcall (luaState, 0, -1, 0) == 0)
return translator.popValues (luaState, oldTop);
else
ThrowExceptionFromError(oldTop);
}
finally
{
ThrowExceptionFromError (oldTop);
} finally {
executing = false;
}
}
else
ThrowExceptionFromError(oldTop);
} else
ThrowExceptionFromError (oldTop);
return null; // Never reached - keeps compiler happy
}
......@@ -375,27 +358,22 @@ namespace LuaInterface
/// <param name = "chunk">Chunk to execute</param>
/// <param name = "chunkName">Name to associate with the chunk</param>
/// <returns></returns>
public object[] DoString(string chunk, string chunkName)
public object[] DoString (string chunk, string chunkName)
{
int oldTop = LuaLib.lua_gettop(luaState);
int oldTop = LuaLib.lua_gettop (luaState);
executing = true;
if(LuaLib.luaL_loadbuffer(luaState, chunk, chunkName) == 0)
{
try
{
if(LuaLib.lua_pcall(luaState, 0, -1, 0) == 0)
return translator.popValues(luaState, oldTop);
if (LuaLib.luaL_loadbuffer (luaState, chunk, chunkName) == 0) {
try {
if (LuaLib.lua_pcall (luaState, 0, -1, 0) == 0)
return translator.popValues (luaState, oldTop);
else
ThrowExceptionFromError(oldTop);
}
finally
{
ThrowExceptionFromError (oldTop);
} finally {
executing = false;
}
}
else
ThrowExceptionFromError(oldTop);
} else
ThrowExceptionFromError (oldTop);
return null; // Never reached - keeps compiler happy
}
......@@ -404,28 +382,23 @@ namespace LuaInterface
* Excutes a Lua file and returns all the chunk's return
* values in an array
*/
public object[] DoFile(string fileName)
public object[] DoFile (string fileName)
{
int oldTop = LuaLib.lua_gettop(luaState);
int oldTop = LuaLib.lua_gettop (luaState);
if(LuaLib.luaL_loadfile(luaState, fileName) == 0)
{
if (LuaLib.luaL_loadfile (luaState, fileName) == 0) {
executing = true;
try
{
if(LuaLib.lua_pcall(luaState, 0, -1, 0) == 0)
return translator.popValues(luaState, oldTop);
try {
if (LuaLib.lua_pcall (luaState, 0, -1, 0) == 0)
return translator.popValues (luaState, oldTop);
else
ThrowExceptionFromError(oldTop);
}
finally
{
ThrowExceptionFromError (oldTop);
} finally {
executing = false;
}
}
else
ThrowExceptionFromError(oldTop);
} else
ThrowExceptionFromError (oldTop);
return null; // Never reached - keeps compiler happy
}
......@@ -435,57 +408,47 @@ namespace LuaInterface
* Indexer for global variables from the LuaInterpreter
* Supports navigation of tables by using . operator
*/
public object this[string fullPath]
{
get
{
public object this [string fullPath] {
get {
object returnValue = null;
int oldTop = LuaLib.lua_gettop(luaState);
string[] path = fullPath.Split(new char[] { '.' });
LuaLib.lua_getglobal(luaState, path[0]);
returnValue = translator.getObject(luaState, -1);
int oldTop = LuaLib.lua_gettop (luaState);
string[] path = fullPath.Split (new char[] { '.' });
LuaLib.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);
if (path.Length > 1) {
string[] remainingPath = new string[path.Length - 1];
Array.Copy (path, 1, remainingPath, 0, path.Length - 1);
returnValue = getObject (remainingPath);
}
LuaLib.lua_settop(luaState, oldTop);
LuaLib.lua_settop (luaState, oldTop);
return returnValue;
}
set
{
int oldTop = LuaLib.lua_gettop(luaState);
string[] path = fullPath.Split(new char[] { '.' });
set {
int oldTop = LuaLib.lua_gettop (luaState);
string[] path = fullPath.Split (new char[] { '.' });
if(path.Length == 1)
{
translator.push(luaState, value);
LuaLib.lua_setglobal(luaState, fullPath);
}
else
{
LuaLib.lua_getglobal(luaState, path[0]);
string[] remainingPath = new string[path.Length-1];
Array.Copy(path, 1, remainingPath, 0, path.Length-1);
setObject(remainingPath, value);
if (path.Length == 1) {
translator.push (luaState, value);
LuaLib.lua_setglobal (luaState, fullPath);
} else {
LuaLib.lua_getglobal (luaState, path [0]);
string[] remainingPath = new string[path.Length - 1];
Array.Copy (path, 1, remainingPath, 0, path.Length - 1);
setObject (remainingPath, value);
}
LuaLib.lua_settop(luaState, oldTop);
LuaLib.lua_settop (luaState, oldTop);
// Globals auto-complete
if(value.IsNull())
{
if (value.IsNull ()) {
// Remove now obsolete entries
globals.Remove(fullPath);
}
else
{
globals.Remove (fullPath);
} else {
// Add new entries
if(!globals.Contains(fullPath))
registerGlobal(fullPath, value.GetType(), 0);
if (!globals.Contains (fullPath))
registerGlobal (fullPath, value.GetType (), 0);
}
}
}
......@@ -497,74 +460,66 @@ namespace LuaInterface
/// <param name = "path">The index accessor path ot the entry</param>
/// <param name = "type">The type of the entry</param>
/// <param name = "recursionCounter">How deep have we gone with recursion?</param>
private void registerGlobal(string path, Type type, int recursionCounter)
private void registerGlobal (string path, Type type, int recursionCounter)
{
// If the type is a global method, list it directly
if(type == typeof(LuaCore.lua_CFunction))
{
if (type == typeof(LuaCore.lua_CFunction)) {
// Format for easy method invocation
globals.Add(path + "(");
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)
{
else if ((type.IsClass || type.IsInterface) && type != typeof(string) && recursionCounter < 2) {
#region Methods
foreach(var method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance))
{
if(
foreach (var 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) &&
(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))
{
!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);
if (method.GetParameters ().Length == 0)
command += ")";
globals.Add (command);
}
}
#endregion
#region Fields
foreach(var field in type.GetFields(BindingFlags.Public | BindingFlags.Instance))
{
if(
foreach (var 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))
{
(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);
registerGlobal (path + "." + field.Name, field.FieldType, recursionCounter + 1);
}
}
#endregion
#region Properties
foreach(var property in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if(
foreach (var 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)
(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")
{
&& property.Name != "Item") {
// Go into recursion for members
registerGlobal(path + "." + property.Name, property.PropertyType, recursionCounter + 1);
registerGlobal (path + "." + property.Name, property.PropertyType, recursionCounter + 1);
}
}
#endregion
}
else
globals.Add(path); // Otherwise simply add the element to the list
} else
globals.Add (path); // Otherwise simply add the element to the list
// List will need to be sorted on next access
globalsSorted = false;
......@@ -575,17 +530,16 @@ namespace LuaInterface
* Navigates a table in the top of the stack, returning
* the value of the specified field
*/
internal object getObject(string[] remainingPath)
internal object getObject (string[] remainingPath)
{
object returnValue = null;
for(int i = 0; i < remainingPath.Length; i++)
{
LuaLib.lua_pushstring(luaState, remainingPath[i]);
LuaLib.lua_gettable(luaState, -2);
returnValue = translator.getObject(luaState, -1);
for (int i = 0; i < remainingPath.Length; i++) {
LuaLib.lua_pushstring (luaState, remainingPath [i]);
LuaLib.lua_gettable (luaState, -2);
returnValue = translator.getObject (luaState, -1);
if(returnValue.IsNull())
if (returnValue.IsNull ())
break;
}
......@@ -595,43 +549,43 @@ namespace LuaInterface
/*
* Gets a numeric global variable
*/
public double GetNumber(string fullPath)
public double GetNumber (string fullPath)
{
return (double)this[fullPath];
return (double)this [fullPath];
}
/*
* Gets a string global variable
*/
public string GetString(string fullPath)
public string GetString (string fullPath)
{
return this[fullPath].ToString();
return this [fullPath].ToString ();
}
/*
* Gets a table global variable
*/
public LuaTable GetTable(string fullPath)
public LuaTable GetTable (string fullPath)
{
return (LuaTable)this[fullPath];
return (LuaTable)this [fullPath];
}
/*
* Gets a table global variable as an object implementing
* the interfaceType interface
*/
public object GetTable(Type interfaceType, string fullPath)
public object GetTable (Type interfaceType, string fullPath)
{
return CodeGeneration.Instance.GetClassInstance(interfaceType, GetTable(fullPath));
return CodeGeneration.Instance.GetClassInstance (interfaceType, GetTable (fullPath));
}
/*
* Gets a function global variable
*/
public LuaFunction GetFunction(string fullPath)
public LuaFunction GetFunction (string fullPath)
{
object obj = this[fullPath];
return (obj is LuaCore.lua_CFunction ? new LuaFunction((LuaCore.lua_CFunction)obj, this) : (LuaFunction)obj);
object obj = this [fullPath];
return (obj is LuaCore.lua_CFunction ? new LuaFunction ((LuaCore.lua_CFunction)obj, this) : (LuaFunction)obj);
}
/*
......@@ -652,18 +606,18 @@ namespace LuaInterface
* Gets a function global variable as a delegate of
* type delegateType
*/
public Delegate GetFunction(Type delegateType, string fullPath)
public Delegate GetFunction (Type delegateType, string fullPath)
{
return CodeGeneration.Instance.GetDelegate(delegateType, GetFunction(fullPath));
return CodeGeneration.Instance.GetDelegate (delegateType, GetFunction (fullPath));
}
/*
* Calls the object as a function with the provided arguments,
* returning the function's returned values inside an array
*/
internal object[] callFunction(object function, object[] args)
internal object[] callFunction (object function, object[] args)
{
return callFunction(function, args, null);
return callFunction (function, args, null);
}
/*
......@@ -671,102 +625,92 @@ namespace LuaInterface
* casting returned values to the types in returnTypes before returning
* them in an array
*/
internal object[] callFunction(object function, object[] args, Type[] returnTypes)
internal object[] callFunction (object function, object[] args, Type[] returnTypes)
{
int nArgs = 0;
int oldTop = LuaLib.lua_gettop(luaState);
int oldTop = LuaLib.lua_gettop (luaState);
if(!LuaLib.lua_checkstack(luaState, args.Length+6))
throw new LuaException("Lua stack overflow");
if (!LuaLib.lua_checkstack (luaState, args.Length + 6))
throw new LuaException ("Lua stack overflow");
translator.push(luaState, function);
translator.push (luaState, function);
if(!args.IsNull())
{
if (!args.IsNull ()) {
nArgs = args.Length;
for(int i = 0; i < args.Length; i++)
translator.push(luaState, args[i]);
for (int i = 0; i < args.Length; i++)
translator.push (luaState, args [i]);
}
executing = true;
try
{
int error = LuaLib.lua_pcall(luaState, nArgs, -1, 0);
if(error != 0)
ThrowExceptionFromError(oldTop);
}
finally
{
try {
int error = LuaLib.lua_pcall (luaState, nArgs, -1, 0);
if (error != 0)
ThrowExceptionFromError (oldTop);
} finally {
executing = false;
}
return !returnTypes.IsNull() ? translator.popValues(luaState, oldTop, returnTypes) : translator.popValues(luaState, oldTop);
return !returnTypes.IsNull () ? translator.popValues (luaState, oldTop, returnTypes) : translator.popValues (luaState, oldTop);
}
/*
* Navigates a table to set the value of one of its fields
*/
internal void setObject(string[] remainingPath, object val)
{
for(int i = 0; i < remainingPath.Length-1; i++)
internal void setObject (string[] remainingPath, object val)
{
LuaLib.lua_pushstring(luaState, remainingPath[i]);
LuaLib.lua_gettable(luaState, -2);
for (int i = 0; i < remainingPath.Length-1; i++) {
LuaLib.lua_pushstring (luaState, remainingPath [i]);
LuaLib.lua_gettable (luaState, -2);
}
LuaLib.lua_pushstring(luaState, remainingPath[remainingPath.Length-1]);
translator.push(luaState, val);
LuaLib.lua_settable(luaState, -3);
LuaLib.lua_pushstring (luaState, remainingPath [remainingPath.Length - 1]);
translator.push (luaState, val);
LuaLib.lua_settable (luaState, -3);
}
/*
* Creates a new table as a global variable or as a field
* inside an existing table
*/
public void NewTable(string fullPath)
public void NewTable (string fullPath)
{
string[] path = fullPath.Split(new char[] { '.' });
int oldTop = LuaLib.lua_gettop(luaState);
string[] path = fullPath.Split (new char[] { '.' });
int oldTop = LuaLib.lua_gettop (luaState);
if(path.Length == 1)
{
LuaLib.lua_newtable(luaState);
LuaLib.lua_setglobal(luaState, fullPath);
}
else
{
LuaLib.lua_getglobal(luaState, path[0]);
if (path.Length == 1) {
LuaLib.lua_newtable (luaState);
LuaLib.lua_setglobal (luaState, fullPath);
} else {
LuaLib.lua_getglobal (luaState, path [0]);
for(int i = 1; i < path.Length-1; i++)
{
LuaLib.lua_pushstring(luaState, path[i]);
LuaLib.lua_gettable(luaState, -2);
for (int i = 1; i < path.Length-1; i++) {
LuaLib.lua_pushstring (luaState, path [i]);
LuaLib.lua_gettable (luaState, -2);
}
LuaLib.lua_pushstring(luaState, path[path.Length-1]);
LuaLib.lua_newtable(luaState);
LuaLib.lua_settable(luaState, -3);
LuaLib.lua_pushstring (luaState, path [path.Length - 1]);
LuaLib.lua_newtable (luaState);
LuaLib.lua_settable (luaState, -3);
}
LuaLib.lua_settop(luaState, oldTop);
LuaLib.lua_settop (luaState, oldTop);
}
public ListDictionary GetTableDict(LuaTable table)
public ListDictionary GetTableDict (LuaTable table)
{
var dict = new ListDictionary();
int oldTop = LuaLib.lua_gettop(luaState);
translator.push(luaState, table);
LuaLib.lua_pushnil(luaState);
var dict = new ListDictionary ();
int oldTop = LuaLib.lua_gettop (luaState);
translator.push (luaState, table);
LuaLib.lua_pushnil (luaState);
while(LuaLib.lua_next(luaState, -2) != 0)
{
dict[translator.getObject(luaState, -2)] = translator.getObject(luaState, -1);
LuaLib.lua_settop(luaState, -2);
while (LuaLib.lua_next(luaState, -2) != 0) {
dict [translator.getObject (luaState, -2)] = translator.getObject (luaState, -1);
LuaLib.lua_settop (luaState, -2);
}
LuaLib.lua_settop(luaState, oldTop);
LuaLib.lua_settop (luaState, oldTop);
return dict;
}
......@@ -782,12 +726,11 @@ namespace LuaInterface
/// <param name = "count">Count</param>
/// <returns>see lua docs. -1 if hook is already set</returns>
/// <author>Reinhard Ostermeier</author>
public int SetDebugHook(EventMasks mask, int count)
public int SetDebugHook (EventMasks mask, int count)
{
if(hookCallback.IsNull())
{
hookCallback = new LuaCore.lua_Hook(DebugHookCallback);
return LuaCore.lua_sethook(luaState, hookCallback, (int)mask, count);
if (hookCallback.IsNull ()) {
hookCallback = new LuaCore.lua_Hook (DebugHookCallback);
return LuaCore.lua_sethook (luaState, hookCallback, (int)mask, count);
}
return -1;
......@@ -798,10 +741,10 @@ namespace LuaInterface
/// </summary>
/// <returns>see lua docs</returns>
/// <author>Reinhard Ostermeier</author>
public int RemoveDebugHook()
public int RemoveDebugHook ()
{
hookCallback = null;
return LuaCore.lua_sethook(luaState, null, 0, 0);
return LuaCore.lua_sethook (luaState, null, 0, 0);
}
/// <summary>
......@@ -809,9 +752,9 @@ namespace LuaInterface
/// </summary>
/// <returns>hook mask</returns>
/// <author>Reinhard Ostermeier</author>
public EventMasks GetHookMask()
public EventMasks GetHookMask ()
{
return (EventMasks)LuaCore.lua_gethookmask(luaState);
return (EventMasks)LuaCore.lua_gethookmask (luaState);
}
/// <summary>
......@@ -819,9 +762,9 @@ namespace LuaInterface
/// </summary>
/// <returns>see lua docs</returns>
/// <author>Reinhard Ostermeier</author>
public int GetHookCount()
public int GetHookCount ()
{
return LuaCore.lua_gethookcount(luaState);
return LuaCore.lua_gethookcount (luaState);
}
/// <summary>
......@@ -876,9 +819,9 @@ namespace LuaInterface
/// <param name = "n">see lua docs</param>
/// <returns>see lua docs</returns>
/// <author>Reinhard Ostermeier</author>
public string GetLocal(LuaCore.lua_Debug luaDebug, int n)
public string GetLocal (LuaCore.lua_Debug luaDebug, int n)
{
return LuaCore.lua_getlocal(luaState, luaDebug, n).ToString();
return LuaCore.lua_getlocal (luaState, luaDebug, n).ToString ();
}
/// <summary>
......@@ -888,9 +831,9 @@ namespace LuaInterface
/// <param name = "n">see lua docs</param>
/// <returns>see lua docs</returns>
/// <author>Reinhard Ostermeier</author>
public string SetLocal(LuaCore.lua_Debug luaDebug, int n)
public string SetLocal (LuaCore.lua_Debug luaDebug, int n)
{
return LuaCore.lua_setlocal(luaState, luaDebug, n).ToString();
return LuaCore.lua_setlocal (luaState, luaDebug, n).ToString ();
}
/// <summary>
......@@ -900,9 +843,9 @@ namespace LuaInterface
/// <param name = "n">see lua docs</param>
/// <returns>see lua docs</returns>
/// <author>Reinhard Ostermeier</author>
public string GetUpValue(int funcindex, int n)
public string GetUpValue (int funcindex, int n)
{
return LuaCore.lua_getupvalue(luaState, funcindex, n).ToString();
return LuaCore.lua_getupvalue (luaState, funcindex, n).ToString ();
}
/// <summary>
......@@ -912,9 +855,9 @@ namespace LuaInterface
/// <param name = "n">see lua docs</param>
/// <returns>see lua docs</returns>
/// <author>Reinhard Ostermeier</author>
public string SetUpValue(int funcindex, int n)
public string SetUpValue (int funcindex, int n)
{
return LuaCore.lua_setupvalue(luaState, funcindex, n).ToString();
return LuaCore.lua_setupvalue (luaState, funcindex, n).ToString ();
}
/// <summary>
......@@ -923,26 +866,23 @@ namespace LuaInterface
/// <param name = "luaState">lua state</param>
/// <param name = "luaDebug">Pointer to LuaDebug (lua_debug) structure</param>
/// <author>Reinhard Ostermeier</author>
private void DebugHookCallback(LuaCore.lua_State luaState, LuaCore.lua_Debug luaDebug)
{
try
private void DebugHookCallback (LuaCore.lua_State luaState, LuaCore.lua_Debug luaDebug)
{
try {
var temp = DebugHook;
if(!temp.IsNull())
temp(this, new DebugHookEventArgs(luaDebug));
}
catch(Exception ex)
{
OnHookException(new HookExceptionEventArgs(ex));
if (!temp.IsNull ())
temp (this, new DebugHookEventArgs (luaDebug));
} catch (Exception ex) {
OnHookException (new HookExceptionEventArgs (ex));
}
}
private void OnHookException(HookExceptionEventArgs e)
private void OnHookException (HookExceptionEventArgs e)
{
var temp = HookException;
if(!temp.IsNull())
temp(this, e);
if (!temp.IsNull ())
temp (this, e);
}
/// <summary>
......@@ -950,10 +890,10 @@ namespace LuaInterface
/// </summary>
/// <returns>Returns the top value from the lua stack.</returns>
/// <author>Reinhard Ostermeier</author>
public object Pop()
public object Pop ()
{
int top = LuaLib.lua_gettop(luaState);
return translator.popValues(luaState, top - 1)[0];
int top = LuaLib.lua_gettop (luaState);
return translator.popValues (luaState, top - 1) [0];
}
/// <summary>
......@@ -961,42 +901,42 @@ namespace LuaInterface
/// </summary>
/// <param name = "value">Value to push.</param>
/// <author>Reinhard Ostermeier</author>
public void Push(object value)
public void Push (object value)
{
translator.push(luaState, value);
translator.push (luaState, value);
}
#endregion
internal void dispose(int reference)
internal void dispose (int reference)
{
if(!luaState.IsNull()) //Fix submitted by Qingrui Li
LuaLib.lua_unref(luaState, reference);
if (!luaState.IsNull ()) //Fix submitted by Qingrui Li
LuaLib.lua_unref (luaState, reference);
}
/*
* Gets a field of the table corresponding to the provided reference
* using rawget (do not use metatables)
*/
internal object rawGetObject(int reference, string field)
{
int oldTop = LuaLib.lua_gettop(luaState);
LuaLib.lua_getref(luaState, reference);
LuaLib.lua_pushstring(luaState, field);
LuaLib.lua_rawget(luaState, -2);
object obj = translator.getObject(luaState, -1);
LuaLib.lua_settop(luaState, oldTop);
internal object rawGetObject (int reference, string field)
{
int oldTop = LuaLib.lua_gettop (luaState);
LuaLib.lua_getref (luaState, reference);
LuaLib.lua_pushstring (luaState, field);
LuaLib.lua_rawget (luaState, -2);
object obj = translator.getObject (luaState, -1);
LuaLib.lua_settop (luaState, oldTop);
return obj;
}
/*
* Gets a field of the table or userdata corresponding to the provided reference
*/
internal object getObject(int reference, string field)
internal object getObject (int reference, string field)
{
int oldTop = LuaLib.lua_gettop(luaState);
LuaLib.lua_getref(luaState, reference);
object returnValue = getObject(field.Split(new char[] {'.'}));
LuaLib.lua_settop(luaState, oldTop);
int oldTop = LuaLib.lua_gettop (luaState);
LuaLib.lua_getref (luaState, reference);
object returnValue = getObject (field.Split (new char[] {'.'}));
LuaLib.lua_settop (luaState, oldTop);
return returnValue;
}
......@@ -1004,14 +944,14 @@ namespace LuaInterface
* Gets a numeric field of the table or userdata corresponding the the provided reference
*/
internal object getObject(int reference, object field)
internal object getObject (int reference, object field)
{
int oldTop = LuaLib.lua_gettop(luaState);
LuaLib.lua_getref(luaState, reference);
translator.push(luaState, field);
LuaLib.lua_gettable(luaState, -2);
object returnValue = translator.getObject(luaState, -1);
LuaLib.lua_settop(luaState, oldTop);
int oldTop = LuaLib.lua_gettop (luaState);
LuaLib.lua_getref (luaState, reference);
translator.push (luaState, field);
LuaLib.lua_gettable (luaState, -2);
object returnValue = translator.getObject (luaState, -1);
LuaLib.lua_settop (luaState, oldTop);
return returnValue;
}
......@@ -1019,74 +959,73 @@ namespace LuaInterface
* Sets a field of the table or userdata corresponding the the provided reference
* to the provided value
*/
internal void setObject(int reference, string field, object val)
internal void setObject (int reference, string field, object val)
{
int oldTop = LuaLib.lua_gettop(luaState);
LuaLib.lua_getref(luaState, reference);
setObject(field.Split(new char[] {'.'}), val);
LuaLib.lua_settop(luaState, oldTop);
int oldTop = LuaLib.lua_gettop (luaState);
LuaLib.lua_getref (luaState, reference);
setObject (field.Split (new char[] {'.'}), val);
LuaLib.lua_settop (luaState, oldTop);
}
/*
* Sets a numeric field of the table or userdata corresponding the the provided reference
* to the provided value
*/
internal void setObject(int reference, object field, object val)
internal void setObject (int reference, object field, object val)
{
int oldTop = LuaLib.lua_gettop(luaState);
LuaLib.lua_getref(luaState, reference);
translator.push(luaState, field);
translator.push(luaState, val);
LuaLib.lua_settable(luaState, -3);
LuaLib.lua_settop(luaState, oldTop);
int oldTop = LuaLib.lua_gettop (luaState);
LuaLib.lua_getref (luaState, reference);
translator.push (luaState, field);
translator.push (luaState, val);
LuaLib.lua_settable (luaState, -3);
LuaLib.lua_settop (luaState, oldTop);
}
/*
* Registers an object's method as a Lua function (global or table field)
* The method may have any signature
*/
public LuaFunction RegisterFunction(string path, object target, MethodBase function /*MethodInfo function*/) //CP: Fix for struct constructor by Alexander Kappner (link: http://luaforge.net/forum/forum.php?thread_id = 2859&forum_id = 145)
public LuaFunction RegisterFunction (string path, object target, MethodBase function /*MethodInfo function*/) //CP: Fix for struct constructor by Alexander Kappner (link: http://luaforge.net/forum/forum.php?thread_id = 2859&forum_id = 145)
{
// We leave nothing on the stack when we are done
int oldTop = LuaLib.lua_gettop(luaState);
var wrapper = new LuaMethodWrapper(translator, target, function.DeclaringType, function);
translator.push(luaState, new LuaCore.lua_CFunction(wrapper.call));
this[path] = translator.getObject(luaState, -1);
var f = GetFunction(path);
LuaLib.lua_settop(luaState, oldTop);
int oldTop = LuaLib.lua_gettop (luaState);
var wrapper = new LuaMethodWrapper (translator, target, function.DeclaringType, function);
translator.push (luaState, new LuaCore.lua_CFunction (wrapper.call));
this [path] = translator.getObject (luaState, -1);
var f = GetFunction (path);
LuaLib.lua_settop (luaState, oldTop);
return f;
}
/*
* Compares the two values referenced by ref1 and ref2 for equality
*/
internal bool compareRef(int ref1, int ref2)
internal bool compareRef (int ref1, int ref2)
{
int top = LuaLib.lua_gettop(luaState);
LuaLib.lua_getref(luaState, ref1);
LuaLib.lua_getref(luaState, ref2);
int equal = LuaLib.lua_equal(luaState, -1, -2);
LuaLib.lua_settop(luaState, top);
int top = LuaLib.lua_gettop (luaState);
LuaLib.lua_getref (luaState, ref1);
LuaLib.lua_getref (luaState, ref2);
int equal = LuaLib.lua_equal (luaState, -1, -2);
LuaLib.lua_settop (luaState, top);
return (equal != 0);
}
internal void pushCSFunction(LuaCore.lua_CFunction function)
internal void pushCSFunction (LuaCore.lua_CFunction function)
{
translator.pushFunction(luaState, function);
translator.pushFunction (luaState, function);
}
#region IDisposable Members
public virtual void Dispose()
{
if(!translator.IsNull())
public virtual void Dispose ()
{
translator.pendingEvents.Dispose();
if (!translator.IsNull ()) {
translator.pendingEvents.Dispose ();
translator = null;
}
this.Close();
GC.Collect();
GC.WaitForPendingFinalizers();
this.Close ();
GC.Collect ();
GC.WaitForPendingFinalizers ();
}
#endregion
}
......
......@@ -22,7 +22,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
using System.Text;
using System.Collections.Generic;
......@@ -36,29 +35,29 @@ namespace LuaInterface
{
private bool _Disposed;
[CLSCompliantAttribute(false)]
protected int _Reference;
protected int
_Reference;
[CLSCompliantAttribute(false)]
protected Lua _Interpreter;
protected Lua
_Interpreter;
~LuaBase()
~LuaBase ()
{
Dispose(false);
Dispose (false);
}
public void Dispose()
public void Dispose ()
{
Dispose(true);
GC.SuppressFinalize(this);
Dispose (true);
GC.SuppressFinalize (this);
}
public virtual void Dispose(bool disposeManagedResources)
{
if(!_Disposed)
{
if(disposeManagedResources)
public virtual void Dispose (bool disposeManagedResources)
{
if(_Reference != 0)
_Interpreter.dispose(_Reference);
if (!_Disposed) {
if (disposeManagedResources) {
if (_Reference != 0)
_Interpreter.dispose (_Reference);
}
_Interpreter = null;
......@@ -66,18 +65,16 @@ namespace LuaInterface
}
}
public override bool Equals(object o)
{
if(o is LuaBase)
public override bool Equals (object o)
{
if (o is LuaBase) {
var l = (LuaBase)o;
return _Interpreter.compareRef(l._Reference, _Reference);
}
else
return _Interpreter.compareRef (l._Reference, _Reference);
} else
return false;
}
public override int GetHashCode()
public override int GetHashCode ()
{
return _Reference;
}
......
......@@ -22,7 +22,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
using System.Text;
using System.Collections.Generic;
......@@ -35,14 +34,14 @@ namespace LuaInterface
{
internal LuaCore.lua_CFunction function;
public LuaFunction(int reference, Lua interpreter)
public LuaFunction (int reference, Lua interpreter)
{
_Reference = reference;
this.function = null;
_Interpreter = interpreter;
}
public LuaFunction(LuaCore.lua_CFunction function, Lua interpreter)
public LuaFunction (LuaCore.lua_CFunction function, Lua interpreter)
{
_Reference = 0;
this.function = function;
......@@ -53,54 +52,52 @@ namespace LuaInterface
* Calls the function casting return values to the types
* in returnTypes
*/
internal object[] call(object[] args, Type[] returnTypes)
internal object[] call (object[] args, Type[] returnTypes)
{
return _Interpreter.callFunction(this, args, returnTypes);
return _Interpreter.callFunction (this, args, returnTypes);
}
/*
* Calls the function and returns its return values inside
* an array
*/
public object[] Call(params object[] args)
public object[] Call (params object[] args)
{
return _Interpreter.callFunction(this, args);
return _Interpreter.callFunction (this, args);
}
/*
* Pushes the function into the Lua stack
*/
internal void push(LuaCore.lua_State luaState)
internal void push (LuaCore.lua_State luaState)
{
if(_Reference != 0)
LuaLib.lua_getref(luaState, _Reference);
if (_Reference != 0)
LuaLib.lua_getref (luaState, _Reference);
else
_Interpreter.pushCSFunction(function);
_Interpreter.pushCSFunction (function);
}
public override string ToString()
public override string ToString ()
{
return "function";
}
public override bool Equals(object o)
{
if(o is LuaFunction)
public override bool Equals (object o)
{
if (o is LuaFunction) {
var l = (LuaFunction)o;
if(this._Reference != 0 && l._Reference != 0)
return _Interpreter.compareRef(l._Reference, this._Reference);
if (this._Reference != 0 && l._Reference != 0)
return _Interpreter.compareRef (l._Reference, this._Reference);
else
return this.function == l.function;
}
else
} else
return false;
}
public override int GetHashCode()
public override int GetHashCode ()
{
return _Reference != 0 ? _Reference : function.GetHashCode();
return _Reference != 0 ? _Reference : function.GetHashCode ();
}
}
}
\ No newline at end of file
......@@ -22,7 +22,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
namespace LuaInterface
......
......@@ -22,7 +22,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
namespace LuaInterface
......
......@@ -23,7 +23,6 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
using System;
namespace LuaInterface
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment