Commit 9aeb3781 authored by Vinicius Jarina's avatar Vinicius Jarina
Browse files

[WinRT] Added Type.GetMethods prototypes to GeneralExtensions.

parent 9160e3e8
...@@ -366,13 +366,6 @@ namespace NLua.Extensions ...@@ -366,13 +366,6 @@ namespace NLua.Extensions
return GetAllDeclaredFieldsRecursively (t); return GetAllDeclaredFieldsRecursively (t);
} }
public static FieldInfo GetPublicField (this Type t, string name)
{
return GetDeclaredFieldRecursively (t, name);
}
static IEnumerable<Type> GetTypes (this Assembly assembly) static IEnumerable<Type> GetTypes (this Assembly assembly)
{ {
return assembly.ExportedTypes; return assembly.ExportedTypes;
...@@ -381,11 +374,61 @@ namespace NLua.Extensions ...@@ -381,11 +374,61 @@ namespace NLua.Extensions
public static bool IsAssignableFrom (this Type t, Type t2) public static bool IsAssignableFrom (this Type t, Type t2)
{ {
return t.GetTypeInfo ().IsAssignableFrom (t2.GetTypeInfo ()); return t.GetTypeInfo ().IsAssignableFrom (t2.GetTypeInfo ());
} }
static IEnumerable<MethodInfo> GetMethods (this Type t, BindingFlags flags) public static MethodInfo[] GetMethods (this Type t)
{
return null;
}
public static MethodInfo [] GetMethods (this Type t, BindingFlags flags)
{ {
return null; return null;
}
public static MethodInfo GetMethod (this Type t, string name, BindingFlags flags)
{
return null;
}
public static MethodInfo GetMethod (this Type t, string name)
{
return null;
}
public static MethodInfo GetMethod (this Type t, string name, BindingFlags bindingAttr, Type[] signature)
{
return null;
}
public static ConstructorInfo [] GetConstructors (this Type t)
{
return null;
}
public static ConstructorInfo GetConstructor (this Type t, Type [] signature)
{
return null;
}
public static FieldInfo GetField (this Type t, string name)
{
return null;
}
public static FieldInfo [] GetFields (this Type t, BindingFlags bindingAttr)
{
return null;
}
public static bool ImplementInterface (this Type t, string name)
{
return false;
}
public static PropertyInfo [] GetProperties (this Type t, BindingFlags bindingAttr)
{
return null;
} }
#endif #endif
} }
......
/* /*
* This file is part of NLua. * This file is part of NLua.
* *
* Copyright (c) 2014 Vinicius Jarina (viniciusjarina@gmail.com) * Copyright (c) 2014 Vinicius Jarina (viniciusjarina@gmail.com)
* Copyright (C) 2003-2005 Fabio Mascarenhas de Queiroz. * Copyright (C) 2003-2005 Fabio Mascarenhas de Queiroz.
* Copyright (C) 2012 Megax <http://megax.yeahunter.hu/> * Copyright (C) 2012 Megax <http://megax.yeahunter.hu/>
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal * of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights * in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is * copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions: * furnished to do so, subject to the following conditions:
* *
* The above copyright notice and this permission notice shall be included in * The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software. * all copies or substantial portions of the Software.
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE. * THE SOFTWARE.
*/ */
using System; using System;
using System.Linq; using System.Linq;
using System.Threading; using System.Threading;
using System.Reflection; using System.Reflection;
#if !MONOTOUCH using NLua.Extensions;
using System.Reflection.Emit;
#endif
using System.Collections; #if !MONOTOUCH
using System.Collections.Generic; using System.Reflection.Emit;
using NLua.Method; #endif
using System.Collections;
namespace NLua using System.Collections.Generic;
{ using NLua.Method;
/*
* Dynamically generates new types from existing types and namespace NLua
* Lua function and table values. Generated types are event handlers, {
* delegates, interface implementations and subclasses. /*
* * Dynamically generates new types from existing types and
* Author: Fabio Mascarenhas * Lua function and table values. Generated types are event handlers,
* Version: 1.0 * delegates, interface implementations and subclasses.
*/ *
class CodeGeneration * Author: Fabio Mascarenhas
{ * Version: 1.0
private Dictionary<Type, LuaClassType> classCollection = new Dictionary<Type, LuaClassType> (); */
private Dictionary<Type, Type> delegateCollection = new Dictionary<Type, Type> (); class CodeGeneration
private static readonly CodeGeneration instance = new CodeGeneration (); {
private AssemblyName assemblyName; private Dictionary<Type, LuaClassType> classCollection = new Dictionary<Type, LuaClassType> ();
private Dictionary<Type, Type> delegateCollection = new Dictionary<Type, Type> ();
#if !MONOTOUCH && !SILVERLIGHT && !NETFX_CORE private static readonly CodeGeneration instance = new CodeGeneration ();
private Dictionary<Type, Type> eventHandlerCollection = new Dictionary<Type, Type> (); private AssemblyName assemblyName;
private Type eventHandlerParent = typeof(LuaEventHandler);
private Type delegateParent = typeof(LuaDelegate); #if !MONOTOUCH && !SILVERLIGHT && !NETFX_CORE
private Type classHelper = typeof(LuaClassHelper); private Dictionary<Type, Type> eventHandlerCollection = new Dictionary<Type, Type> ();
private AssemblyBuilder newAssembly; private Type eventHandlerParent = typeof(LuaEventHandler);
private ModuleBuilder newModule; private Type delegateParent = typeof(LuaDelegate);
private int luaClassNumber = 1; private Type classHelper = typeof(LuaClassHelper);
#endif private AssemblyBuilder newAssembly;
private ModuleBuilder newModule;
static CodeGeneration () private int luaClassNumber = 1;
{ #endif
}
static CodeGeneration ()
private CodeGeneration () {
{ }
// Create an assembly name
assemblyName = new AssemblyName (); private CodeGeneration ()
assemblyName.Name = "NLua_generatedcode"; {
// Create a new assembly with one module. // Create an assembly name
#if !MONOTOUCH && !SILVERLIGHT && !NETFX_CORE assemblyName = new AssemblyName ();
newAssembly = Thread.GetDomain ().DefineDynamicAssembly (assemblyName, AssemblyBuilderAccess.Run); assemblyName.Name = "NLua_generatedcode";
newModule = newAssembly.DefineDynamicModule ("NLua_generatedcode"); // Create a new assembly with one module.
#endif #if !MONOTOUCH && !SILVERLIGHT && !NETFX_CORE
} newAssembly = Thread.GetDomain ().DefineDynamicAssembly (assemblyName, AssemblyBuilderAccess.Run);
newModule = newAssembly.DefineDynamicModule ("NLua_generatedcode");
/* #endif
* Singleton instance of the class }
*/
public static CodeGeneration Instance { /*
get { return instance; } * Singleton instance of the class
} */
public static CodeGeneration Instance {
/* get { return instance; }
* Generates an event handler that calls a Lua function }
*/
private Type GenerateEvent (Type eventHandlerType) /*
{ * Generates an event handler that calls a Lua function
#if MONOTOUCH */
throw new NotImplementedException (" Emit not available on MonoTouch "); private Type GenerateEvent (Type eventHandlerType)
#elif SILVERLIGHT {
throw new NotImplementedException(" Emit not available on Silverlight "); #if MONOTOUCH
#elif NETFX_CORE throw new NotImplementedException (" Emit not available on MonoTouch ");
throw new NotImplementedException(" Emit not available on Windows Store "); #elif SILVERLIGHT
#else throw new NotImplementedException(" Emit not available on Silverlight ");
string typeName; #elif NETFX_CORE
lock (this) { throw new NotImplementedException(" Emit not available on Windows Store ");
typeName = "LuaGeneratedClass" + luaClassNumber.ToString (); #else
luaClassNumber++; string typeName;
} lock (this) {
typeName = "LuaGeneratedClass" + luaClassNumber.ToString ();
// Define a public class in the assembly, called typeName luaClassNumber++;
var myType = newModule.DefineType (typeName, TypeAttributes.Public, eventHandlerParent); }
// Defines the handler method. Its signature is void(object, <subclassofEventArgs>) // Define a public class in the assembly, called typeName
var paramTypes = new Type[2]; var myType = newModule.DefineType (typeName, TypeAttributes.Public, eventHandlerParent);
paramTypes [0] = typeof(object);
paramTypes [1] = eventHandlerType; // Defines the handler method. Its signature is void(object, <subclassofEventArgs>)
var returnType = typeof(void); var paramTypes = new Type[2];
var handleMethod = myType.DefineMethod ("HandleEvent", MethodAttributes.Public | MethodAttributes.HideBySig, returnType, paramTypes); paramTypes [0] = typeof(object);
paramTypes [1] = eventHandlerType;
// Emits the IL for the method. It loads the arguments var returnType = typeof(void);
// and calls the handleEvent method of the base class var handleMethod = myType.DefineMethod ("HandleEvent", MethodAttributes.Public | MethodAttributes.HideBySig, returnType, paramTypes);
ILGenerator generator = handleMethod.GetILGenerator ();
generator.Emit (OpCodes.Ldarg_0); // Emits the IL for the method. It loads the arguments
generator.Emit (OpCodes.Ldarg_1); // and calls the handleEvent method of the base class
generator.Emit (OpCodes.Ldarg_2); ILGenerator generator = handleMethod.GetILGenerator ();
var miGenericEventHandler = eventHandlerParent.GetMethod ("HandleEvent"); generator.Emit (OpCodes.Ldarg_0);
generator.Emit (OpCodes.Call, miGenericEventHandler); generator.Emit (OpCodes.Ldarg_1);
// returns generator.Emit (OpCodes.Ldarg_2);
generator.Emit (OpCodes.Ret); var miGenericEventHandler = eventHandlerParent.GetMethod ("HandleEvent");
// creates the new type generator.Emit (OpCodes.Call, miGenericEventHandler);
return myType.CreateType (); // returns
#endif generator.Emit (OpCodes.Ret);
} // creates the new type
return myType.CreateType ();
/* #endif
* Generates a type that can be used for instantiating a delegate }
* of the provided type, given a Lua function.
*/ /*
private Type GenerateDelegate (Type delegateType) * Generates a type that can be used for instantiating a delegate
{ * of the provided type, given a Lua function.
#if MONOTOUCH */
throw new NotImplementedException ("GenerateDelegate is not available on iOS, please register your LuaDelegate type with Lua.RegisterLuaDelegateType( yourDelegate, theLuaDelegateHandler) "); private Type GenerateDelegate (Type delegateType)
#elif SILVERLIGHT {
throw new NotImplementedException("GenerateDelegate is not available on Silverlight, please register your LuaDelegate type with Lua.RegisterLuaDelegateType( yourDelegate, theLuaDelegateHandler) "); #if MONOTOUCH
#elif NETFX_CORE throw new NotImplementedException ("GenerateDelegate is not available on iOS, please register your LuaDelegate type with Lua.RegisterLuaDelegateType( yourDelegate, theLuaDelegateHandler) ");
throw new NotImplementedException("GenerateDelegate is not available on Windows Store, please register your LuaDelegate type with Lua.RegisterLuaDelegateType( yourDelegate, theLuaDelegateHandler) "); #elif SILVERLIGHT
#else throw new NotImplementedException("GenerateDelegate is not available on Silverlight, please register your LuaDelegate type with Lua.RegisterLuaDelegateType( yourDelegate, theLuaDelegateHandler) ");
string typeName; #elif NETFX_CORE
lock (this) { throw new NotImplementedException("GenerateDelegate is not available on Windows Store, please register your LuaDelegate type with Lua.RegisterLuaDelegateType( yourDelegate, theLuaDelegateHandler) ");
typeName = "LuaGeneratedClass" + luaClassNumber.ToString (); #else
luaClassNumber++; string typeName;
} lock (this) {
typeName = "LuaGeneratedClass" + luaClassNumber.ToString ();
// Define a public class in the assembly, called typeName luaClassNumber++;
var myType = newModule.DefineType (typeName, TypeAttributes.Public, delegateParent); }
// Defines the delegate method with the same signature as the // Define a public class in the assembly, called typeName
// Invoke method of delegateType var myType = newModule.DefineType (typeName, TypeAttributes.Public, delegateParent);
var invokeMethod = delegateType.GetMethod ("Invoke");
var paramInfo = invokeMethod.GetParameters (); // Defines the delegate method with the same signature as the
var paramTypes = new Type[paramInfo.Length]; // Invoke method of delegateType
var returnType = invokeMethod.ReturnType; var invokeMethod = delegateType.GetMethod ("Invoke");
var paramInfo = invokeMethod.GetParameters ();
// Counts out and ref params, for use later var paramTypes = new Type[paramInfo.Length];
int nOutParams = 0; var returnType = invokeMethod.ReturnType;
int nOutAndRefParams = 0;
// Counts out and ref params, for use later
for (int i = 0; i < paramTypes.Length; i++) { int nOutParams = 0;
paramTypes [i] = paramInfo [i].ParameterType; int nOutAndRefParams = 0;
if ((!paramInfo [i].IsIn) && paramInfo [i].IsOut) for (int i = 0; i < paramTypes.Length; i++) {
nOutParams++; paramTypes [i] = paramInfo [i].ParameterType;
if (paramTypes [i].IsByRef) if ((!paramInfo [i].IsIn) && paramInfo [i].IsOut)
nOutAndRefParams++; nOutParams++;
}
if (paramTypes [i].IsByRef)
int[] refArgs = new int[nOutAndRefParams]; nOutAndRefParams++;
var delegateMethod = myType.DefineMethod ("CallFunction", invokeMethod.Attributes, returnType, paramTypes); }
// Generates the IL for the method int[] refArgs = new int[nOutAndRefParams];
ILGenerator generator = delegateMethod.GetILGenerator (); var delegateMethod = myType.DefineMethod ("CallFunction", invokeMethod.Attributes, returnType, paramTypes);
generator.DeclareLocal (typeof(object[])); // original arguments
generator.DeclareLocal (typeof(object[])); // with out-only arguments removed // Generates the IL for the method
generator.DeclareLocal (typeof(int[])); // indexes of out and ref arguments ILGenerator generator = delegateMethod.GetILGenerator ();
generator.DeclareLocal (typeof(object[])); // original arguments
if (!(returnType == typeof(void))) // return value generator.DeclareLocal (typeof(object[])); // with out-only arguments removed
generator.DeclareLocal (returnType); generator.DeclareLocal (typeof(int[])); // indexes of out and ref arguments
else
generator.DeclareLocal (typeof(object)); if (!(returnType == typeof(void))) // return value
generator.DeclareLocal (returnType);
// Initializes local variables else
generator.Emit (OpCodes.Ldc_I4, paramTypes.Length); generator.DeclareLocal (typeof(object));
generator.Emit (OpCodes.Newarr, typeof(object));
generator.Emit (OpCodes.Stloc_0); // Initializes local variables
generator.Emit (OpCodes.Ldc_I4, paramTypes.Length - nOutParams); generator.Emit (OpCodes.Ldc_I4, paramTypes.Length);
generator.Emit (OpCodes.Newarr, typeof(object)); generator.Emit (OpCodes.Newarr, typeof(object));
generator.Emit (OpCodes.Stloc_1); generator.Emit (OpCodes.Stloc_0);
generator.Emit (OpCodes.Ldc_I4, nOutAndRefParams); generator.Emit (OpCodes.Ldc_I4, paramTypes.Length - nOutParams);
generator.Emit (OpCodes.Newarr, typeof(int)); generator.Emit (OpCodes.Newarr, typeof(object));
generator.Emit (OpCodes.Stloc_2); generator.Emit (OpCodes.Stloc_1);
generator.Emit (OpCodes.Ldc_I4, nOutAndRefParams);
// Stores the arguments in the local variables generator.Emit (OpCodes.Newarr, typeof(int));
for (int iArgs = 0, iInArgs = 0, iOutArgs = 0; iArgs < paramTypes.Length; iArgs++) { generator.Emit (OpCodes.Stloc_2);
generator.Emit (OpCodes.Ldloc_0);
generator.Emit (OpCodes.Ldc_I4, iArgs); // Stores the arguments in the local variables
generator.Emit (OpCodes.Ldarg, iArgs + 1); for (int iArgs = 0, iInArgs = 0, iOutArgs = 0; iArgs < paramTypes.Length; iArgs++) {
generator.Emit (OpCodes.Ldloc_0);
if (paramTypes [iArgs].IsByRef) { generator.Emit (OpCodes.Ldc_I4, iArgs);
if (paramTypes [iArgs].GetElementType ().IsValueType) { generator.Emit (OpCodes.Ldarg, iArgs + 1);
generator.Emit (OpCodes.Ldobj, paramTypes [iArgs].GetElementType ());
generator.Emit (OpCodes.Box, paramTypes [iArgs].GetElementType ()); if (paramTypes [iArgs].IsByRef) {
} else if (paramTypes [iArgs].GetElementType ().IsValueType) {
generator.Emit (OpCodes.Ldind_Ref); generator.Emit (OpCodes.Ldobj, paramTypes [iArgs].GetElementType ());
} else { generator.Emit (OpCodes.Box, paramTypes [iArgs].GetElementType ());
if (paramTypes [iArgs].IsValueType) } else
generator.Emit (OpCodes.Box, paramTypes [iArgs]); generator.Emit (OpCodes.Ldind_Ref);
} } else {
if (paramTypes [iArgs].IsValueType)
generator.Emit (OpCodes.Stelem_Ref); generator.Emit (OpCodes.Box, paramTypes [iArgs]);
}
if (paramTypes [iArgs].IsByRef) {
generator.Emit (OpCodes.Ldloc_2); generator.Emit (OpCodes.Stelem_Ref);
generator.Emit (OpCodes.Ldc_I4, iOutArgs);
generator.Emit (OpCodes.Ldc_I4, iArgs); if (paramTypes [iArgs].IsByRef) {
generator.Emit (OpCodes.Stelem_I4); generator.Emit (OpCodes.Ldloc_2);
refArgs [iOutArgs] = iArgs; generator.Emit (OpCodes.Ldc_I4, iOutArgs);
iOutArgs++; generator.Emit (OpCodes.Ldc_I4, iArgs);
} generator.Emit (OpCodes.Stelem_I4);
refArgs [iOutArgs] = iArgs;
if (paramInfo [iArgs].IsIn || (!paramInfo [iArgs].IsOut)) { iOutArgs++;
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);
if (paramTypes [iArgs].IsByRef) { generator.Emit (OpCodes.Ldc_I4, iInArgs);
if (paramTypes [iArgs].GetElementType ().IsValueType) { generator.Emit (OpCodes.Ldarg, iArgs + 1);
generator.Emit (OpCodes.Ldobj, paramTypes [iArgs].GetElementType ());
generator.Emit (OpCodes.Box, paramTypes [iArgs].GetElementType ()); if (paramTypes [iArgs].IsByRef) {
} else if (paramTypes [iArgs].GetElementType ().IsValueType) {
generator.Emit (OpCodes.Ldind_Ref); generator.Emit (OpCodes.Ldobj, paramTypes [iArgs].GetElementType ());
} else { generator.Emit (OpCodes.Box, paramTypes [iArgs].GetElementType ());
if (paramTypes [iArgs].IsValueType) } else
generator.Emit (OpCodes.Box, paramTypes [iArgs]); generator.Emit (OpCodes.Ldind_Ref);
} } else {
if (paramTypes [iArgs].IsValueType)
generator.Emit (OpCodes.Stelem_Ref); generator.Emit (OpCodes.Box, paramTypes [iArgs]);
iInArgs++; }
}
} 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); // Calls the callFunction method of the base class
generator.Emit (OpCodes.Ldloc_2); generator.Emit (OpCodes.Ldarg_0);
var miGenericEventHandler = delegateParent.GetMethod ("CallFunction"); generator.Emit (OpCodes.Ldloc_0);
generator.Emit (OpCodes.Call, miGenericEventHandler); generator.Emit (OpCodes.Ldloc_1);
generator.Emit (OpCodes.Ldloc_2);
// Stores return value var miGenericEventHandler = delegateParent.GetMethod ("CallFunction");
if (returnType == typeof(void)) { generator.Emit (OpCodes.Call, miGenericEventHandler);
generator.Emit (OpCodes.Pop);
generator.Emit (OpCodes.Ldnull); // Stores return value
} else if (returnType.IsValueType) { if (returnType == typeof(void)) {
generator.Emit (OpCodes.Unbox, returnType); generator.Emit (OpCodes.Pop);
generator.Emit (OpCodes.Ldobj, returnType); generator.Emit (OpCodes.Ldnull);
} else } else if (returnType.IsValueType) {
generator.Emit (OpCodes.Castclass, returnType); generator.Emit (OpCodes.Unbox, returnType);
generator.Emit (OpCodes.Ldobj, returnType);
generator.Emit (OpCodes.Stloc_3); } else
generator.Emit (OpCodes.Castclass, returnType);
// Stores new value of out and ref params
for (int i = 0; i < refArgs.Length; i++) { generator.Emit (OpCodes.Stloc_3);
generator.Emit (OpCodes.Ldarg, refArgs [i] + 1);
generator.Emit (OpCodes.Ldloc_0); // Stores new value of out and ref params
generator.Emit (OpCodes.Ldc_I4, refArgs [i]); for (int i = 0; i < refArgs.Length; i++) {
generator.Emit (OpCodes.Ldelem_Ref); generator.Emit (OpCodes.Ldarg, refArgs [i] + 1);
generator.Emit (OpCodes.Ldloc_0);
if (paramTypes [refArgs [i]].GetElementType ().IsValueType) { generator.Emit (OpCodes.Ldc_I4, refArgs [i]);
generator.Emit (OpCodes.Unbox, paramTypes [refArgs [i]].GetElementType ()); generator.Emit (OpCodes.Ldelem_Ref);
generator.Emit (OpCodes.Ldobj, paramTypes [refArgs [i]].GetElementType ());
generator.Emit (OpCodes.Stobj, paramTypes [refArgs [i]].GetElementType ()); if (paramTypes [refArgs [i]].GetElementType ().IsValueType) {
} else { generator.Emit (OpCodes.Unbox, paramTypes [refArgs [i]].GetElementType ());
generator.Emit (OpCodes.Castclass, paramTypes [refArgs [i]].GetElementType ()); generator.Emit (OpCodes.Ldobj, paramTypes [refArgs [i]].GetElementType ());
generator.Emit (OpCodes.Stind_Ref); 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);
// Returns
generator.Emit (OpCodes.Ret); if (!(returnType == typeof(void)))
return myType.CreateType (); // creates the new type generator.Emit (OpCodes.Ldloc_3);
#endif
} generator.Emit (OpCodes.Ret);
return myType.CreateType (); // creates the new type
void GetReturnTypesFromClass (Type klass, out Type[][] returnTypes) #endif
{ }
var classMethods = klass.GetMethods ();
returnTypes = new Type[classMethods.Length][]; void GetReturnTypesFromClass (Type klass, out Type[][] returnTypes)
{
int i = 0; var classMethods = klass.GetMethods ();
returnTypes = new Type[classMethods.Length][];
foreach (var method in classMethods) {
if (klass.IsInterface) { int i = 0;
GetReturnTypesFromMethod (method, out returnTypes [i]);
i++; foreach (var method in classMethods) {
} else { if (klass.IsInterface ()) {
if (!method.IsPrivate && !method.IsFinal && method.IsVirtual) { GetReturnTypesFromMethod (method, out returnTypes [i]);
GetReturnTypesFromMethod (method, out returnTypes [i]); i++;
i++; } else {
} if (!method.IsPrivate && !method.IsFinal && method.IsVirtual) {
} GetReturnTypesFromMethod (method, out returnTypes [i]);
} i++;
} }
}
/* }
* 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) * Generates an implementation of klass, if it is an interface, or
{ * a subclass of klass that delegates its virtual methods to a Lua table.
#if MONOTOUCH */
throw new NotImplementedException (" Emit not available on MonoTouch "); public void GenerateClass (Type klass, out Type newType, out Type[][] returnTypes)
#elif SILVERLIGHT {
throw new NotImplementedException (" Emit not available on Silverlight "); #if MONOTOUCH
#elif NETFX_CORE throw new NotImplementedException (" Emit not available on MonoTouch ");
throw new NotImplementedException (" Emit not available on Windows Store "); #elif SILVERLIGHT
#else throw new NotImplementedException (" Emit not available on Silverlight ");
string typeName; #elif NETFX_CORE
lock (this) { throw new NotImplementedException (" Emit not available on Windows Store ");
typeName = "LuaGeneratedClass" + luaClassNumber.ToString (); #else
luaClassNumber++; string typeName;
} lock (this) {
typeName = "LuaGeneratedClass" + luaClassNumber.ToString ();
TypeBuilder myType; luaClassNumber++;
// Define a public class in the assembly, called typeName }
if (klass.IsInterface)
myType = newModule.DefineType (typeName, TypeAttributes.Public, typeof(object), new Type[] { TypeBuilder myType;
klass, // Define a public class in the assembly, called typeName
typeof(ILuaGeneratedType) if (klass.IsInterface)
}); myType = newModule.DefineType (typeName, TypeAttributes.Public, typeof(object), new Type[] {
else klass,
myType = newModule.DefineType (typeName, TypeAttributes.Public, klass, new Type[] { typeof(ILuaGeneratedType) }); typeof(ILuaGeneratedType)
});
// Field that stores the Lua table else
var luaTableField = myType.DefineField ("__luaInterface_luaTable", typeof(LuaTable), FieldAttributes.Public); myType = newModule.DefineType (typeName, TypeAttributes.Public, klass, new Type[] { typeof(ILuaGeneratedType) });
// Field that stores the return types array
var returnTypesField = myType.DefineField ("__luaInterface_returnTypes", typeof(Type[][]), FieldAttributes.Public); // Field that stores the Lua table
// Generates the constructor for the new type, it takes a Lua table and an array var luaTableField = myType.DefineField ("__luaInterface_luaTable", typeof(LuaTable), FieldAttributes.Public);
// of return types and stores them in the respective fields // Field that stores the return types array
var constructor = myType.DefineConstructor (MethodAttributes.Public, CallingConventions.Standard, new Type[] { var returnTypesField = myType.DefineField ("__luaInterface_returnTypes", typeof(Type[][]), FieldAttributes.Public);
typeof(LuaTable), // Generates the constructor for the new type, it takes a Lua table and an array
typeof(Type[][]) // of return types and stores them in the respective fields
}); var constructor = myType.DefineConstructor (MethodAttributes.Public, CallingConventions.Standard, new Type[] {
ILGenerator generator = constructor.GetILGenerator (); typeof(LuaTable),
generator.Emit (OpCodes.Ldarg_0); typeof(Type[][])
});
if (klass.IsInterface) ILGenerator generator = constructor.GetILGenerator ();
generator.Emit (OpCodes.Call, typeof(object).GetConstructor (Type.EmptyTypes)); generator.Emit (OpCodes.Ldarg_0);
else
generator.Emit (OpCodes.Call, klass.GetConstructor (Type.EmptyTypes)); if (klass.IsInterface)
generator.Emit (OpCodes.Call, typeof(object).GetConstructor (Type.EmptyTypes));
generator.Emit (OpCodes.Ldarg_0); else
generator.Emit (OpCodes.Ldarg_1); generator.Emit (OpCodes.Call, klass.GetConstructor (Type.EmptyTypes));
generator.Emit (OpCodes.Stfld, luaTableField);
generator.Emit (OpCodes.Ldarg_0); generator.Emit (OpCodes.Ldarg_0);
generator.Emit (OpCodes.Ldarg_2); generator.Emit (OpCodes.Ldarg_1);
generator.Emit (OpCodes.Stfld, returnTypesField); generator.Emit (OpCodes.Stfld, luaTableField);
generator.Emit (OpCodes.Ret); generator.Emit (OpCodes.Ldarg_0);
// Generates overriden versions of the klass' public virtual methods generator.Emit (OpCodes.Ldarg_2);
var classMethods = klass.GetMethods (); generator.Emit (OpCodes.Stfld, returnTypesField);
returnTypes = new Type[classMethods.Length][]; generator.Emit (OpCodes.Ret);
int i = 0; // Generates overriden versions of the klass' public virtual methods
var classMethods = klass.GetMethods ();
foreach (var method in classMethods) { returnTypes = new Type[classMethods.Length][];
if (klass.IsInterface) { int i = 0;
GenerateMethod (myType, method, MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.NewSlot,
i, luaTableField, returnTypesField, false, out returnTypes [i]); foreach (var method in classMethods) {
i++; if (klass.IsInterface) {
} else { GenerateMethod (myType, method, MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.NewSlot,
if (!method.IsPrivate && !method.IsFinal && method.IsVirtual) { i, luaTableField, returnTypesField, false, out returnTypes [i]);
GenerateMethod (myType, method, (method.Attributes | MethodAttributes.NewSlot) ^ MethodAttributes.NewSlot, i, i++;
luaTableField, returnTypesField, true, out returnTypes [i]); } else {
i++; 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 luaInterfaceGetLuaTable method }
var returnTableMethod = myType.DefineMethod ("LuaInterfaceGetLuaTable", }
MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual, typeof(LuaTable), new Type[0]);
myType.DefineMethodOverride (returnTableMethod, typeof(ILuaGeneratedType).GetMethod ("LuaInterfaceGetLuaTable")); // Generates an implementation of the luaInterfaceGetLuaTable method
generator = returnTableMethod.GetILGenerator (); var returnTableMethod = myType.DefineMethod ("LuaInterfaceGetLuaTable",
generator.Emit (OpCodes.Ldfld, luaTableField); MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual, typeof(LuaTable), new Type[0]);
generator.Emit (OpCodes.Ret); myType.DefineMethodOverride (returnTableMethod, typeof(ILuaGeneratedType).GetMethod ("LuaInterfaceGetLuaTable"));
newType = myType.CreateType (); // Creates the type generator = returnTableMethod.GetILGenerator ();
#endif generator.Emit (OpCodes.Ldfld, luaTableField);
} generator.Emit (OpCodes.Ret);
newType = myType.CreateType (); // Creates the type
void GetReturnTypesFromMethod (MethodInfo method, out Type[] returnTypes) #endif
{ }
var paramInfo = method.GetParameters ();
var paramTypes = new Type[paramInfo.Length]; void GetReturnTypesFromMethod (MethodInfo method, out Type[] returnTypes)
var returnTypesList = new List<Type> (); {
var paramInfo = method.GetParameters ();
// Counts out and ref parameters, for later use, var paramTypes = new Type[paramInfo.Length];
// and creates the list of return types var returnTypesList = new List<Type> ();
int nOutParams = 0;
int nOutAndRefParams = 0; // Counts out and ref parameters, for later use,
var returnType = method.ReturnType; // and creates the list of return types
returnTypesList.Add (returnType); int nOutParams = 0;
int nOutAndRefParams = 0;
for (int i = 0; i < paramTypes.Length; i++) { var returnType = method.ReturnType;
paramTypes [i] = paramInfo [i].ParameterType; returnTypesList.Add (returnType);
#if SILVERLIGHT
if (paramInfo[i].IsOut) { for (int i = 0; i < paramTypes.Length; i++) {
#else paramTypes [i] = paramInfo [i].ParameterType;
if ((!paramInfo [i].IsIn) && paramInfo [i].IsOut) { #if SILVERLIGHT
#endif if (paramInfo[i].IsOut) {
nOutParams++; #else
} if ((!paramInfo [i].IsIn) && paramInfo [i].IsOut) {
#endif
if (paramTypes [i].IsByRef) { nOutParams++;
returnTypesList.Add (paramTypes [i].GetElementType ()); }
nOutAndRefParams++;
} if (paramTypes [i].IsByRef) {
} returnTypesList.Add (paramTypes [i].GetElementType ());
nOutAndRefParams++;
returnTypes = returnTypesList.ToArray (); }
} }
#if !MONOTOUCH && !SILVERLIGHT && !NETFX_CORE returnTypes = returnTypesList.ToArray ();
}
/*
* Generates an overriden implementation of method inside myType that delegates #if !MONOTOUCH && !SILVERLIGHT && !NETFX_CORE
* to a function in a Lua table with the same name, if the function exists. If it
* doesn't the method calls the base method (or does nothing, in case of interface /*
* implementations). * Generates an overriden implementation of method inside myType that delegates
*/ * to a function in a Lua table with the same name, if the function exists. If it
private void GenerateMethod (TypeBuilder myType, MethodInfo method, MethodAttributes attributes, int methodIndex, * doesn't the method calls the base method (or does nothing, in case of interface
FieldInfo luaTableField, FieldInfo returnTypesField, bool generateBase, out Type[] returnTypes) * implementations).
{ */
var paramInfo = method.GetParameters (); private void GenerateMethod (TypeBuilder myType, MethodInfo method, MethodAttributes attributes, int methodIndex,
var paramTypes = new Type[paramInfo.Length]; FieldInfo luaTableField, FieldInfo returnTypesField, bool generateBase, out Type[] returnTypes)
var returnTypesList = new List<Type> (); {
var paramInfo = method.GetParameters ();
// Counts out and ref parameters, for later use, var paramTypes = new Type[paramInfo.Length];
// and creates the list of return types var returnTypesList = new List<Type> ();
int nOutParams = 0;
int nOutAndRefParams = 0; // Counts out and ref parameters, for later use,
var returnType = method.ReturnType; // and creates the list of return types
returnTypesList.Add (returnType); int nOutParams = 0;
int nOutAndRefParams = 0;
for (int i = 0; i < paramTypes.Length; i++) { var returnType = method.ReturnType;
paramTypes [i] = paramInfo [i].ParameterType; returnTypesList.Add (returnType);
if ((!paramInfo [i].IsIn) && paramInfo [i].IsOut)
nOutParams++; for (int i = 0; i < paramTypes.Length; i++) {
paramTypes [i] = paramInfo [i].ParameterType;
if (paramTypes [i].IsByRef) { if ((!paramInfo [i].IsIn) && paramInfo [i].IsOut)
returnTypesList.Add (paramTypes [i].GetElementType ()); nOutParams++;
nOutAndRefParams++;
} if (paramTypes [i].IsByRef) {
} returnTypesList.Add (paramTypes [i].GetElementType ());
nOutAndRefParams++;
int[] refArgs = new int[nOutAndRefParams]; }
returnTypes = returnTypesList.ToArray (); }
// Generates a version of the method that calls the base implementation int[] refArgs = new int[nOutAndRefParams];
// directly, for use by the base field of the table returnTypes = returnTypesList.ToArray ();
if (generateBase) {
var baseMethod = myType.DefineMethod ("__luaInterface_base_" + method.Name, // Generates a version of the method that calls the base implementation
MethodAttributes.Private | MethodAttributes.NewSlot | MethodAttributes.HideBySig, // directly, for use by the base field of the table
returnType, paramTypes); if (generateBase) {
ILGenerator generatorBase = baseMethod.GetILGenerator (); var baseMethod = myType.DefineMethod ("__luaInterface_base_" + method.Name,
generatorBase.Emit (OpCodes.Ldarg_0); MethodAttributes.Private | MethodAttributes.NewSlot | MethodAttributes.HideBySig,
returnType, paramTypes);
for (int i = 0; i < paramTypes.Length; i++) ILGenerator generatorBase = baseMethod.GetILGenerator ();
generatorBase.Emit (OpCodes.Ldarg, i + 1); generatorBase.Emit (OpCodes.Ldarg_0);
generatorBase.Emit (OpCodes.Call, method); for (int i = 0; i < paramTypes.Length; i++)
generatorBase.Emit (OpCodes.Ldarg, i + 1);
if (returnType == typeof(void))
generatorBase.Emit (OpCodes.Pop); generatorBase.Emit (OpCodes.Call, method);
generatorBase.Emit (OpCodes.Ret); if (returnType == typeof(void))
} generatorBase.Emit (OpCodes.Pop);
// Defines the method generatorBase.Emit (OpCodes.Ret);
var methodImpl = myType.DefineMethod (method.Name, attributes, returnType, paramTypes); }
// If it's an implementation of an interface tells what method it // Defines the method
// is overriding var methodImpl = myType.DefineMethod (method.Name, attributes, returnType, paramTypes);
if (myType.BaseType.Equals (typeof(object)))
myType.DefineMethodOverride (methodImpl, method); // If it's an implementation of an interface tells what method it
// is overriding
ILGenerator generator = methodImpl.GetILGenerator (); if (myType.BaseType.Equals (typeof(object)))
generator.DeclareLocal (typeof(object[])); // original arguments myType.DefineMethodOverride (methodImpl, method);
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
if (!(returnType == typeof(void))) // return value generator.DeclareLocal (typeof(object[])); // with out-only arguments removed
generator.DeclareLocal (returnType); generator.DeclareLocal (typeof(int[])); // indexes of out and ref arguments
else
generator.DeclareLocal (typeof(object)); if (!(returnType == typeof(void))) // return value
generator.DeclareLocal (returnType);
// Initializes local variables else
generator.Emit (OpCodes.Ldc_I4, paramTypes.Length); generator.DeclareLocal (typeof(object));
generator.Emit (OpCodes.Newarr, typeof(object));
generator.Emit (OpCodes.Stloc_0); // Initializes local variables
generator.Emit (OpCodes.Ldc_I4, paramTypes.Length - nOutParams + 1); generator.Emit (OpCodes.Ldc_I4, paramTypes.Length);
generator.Emit (OpCodes.Newarr, typeof(object)); generator.Emit (OpCodes.Newarr, typeof(object));
generator.Emit (OpCodes.Stloc_1); generator.Emit (OpCodes.Stloc_0);
generator.Emit (OpCodes.Ldc_I4, nOutAndRefParams); generator.Emit (OpCodes.Ldc_I4, paramTypes.Length - nOutParams + 1);
generator.Emit (OpCodes.Newarr, typeof(int)); generator.Emit (OpCodes.Newarr, typeof(object));
generator.Emit (OpCodes.Stloc_2); generator.Emit (OpCodes.Stloc_1);
generator.Emit (OpCodes.Ldloc_1); generator.Emit (OpCodes.Ldc_I4, nOutAndRefParams);
generator.Emit (OpCodes.Ldc_I4_0); generator.Emit (OpCodes.Newarr, typeof(int));
generator.Emit (OpCodes.Ldarg_0); generator.Emit (OpCodes.Stloc_2);
generator.Emit (OpCodes.Ldfld, luaTableField); generator.Emit (OpCodes.Ldloc_1);
generator.Emit (OpCodes.Stelem_Ref); generator.Emit (OpCodes.Ldc_I4_0);
generator.Emit (OpCodes.Ldarg_0);
// Stores the arguments into the local variables, as needed generator.Emit (OpCodes.Ldfld, luaTableField);
for (int iArgs = 0, iInArgs = 1, iOutArgs = 0; iArgs < paramTypes.Length; iArgs++) { generator.Emit (OpCodes.Stelem_Ref);
generator.Emit (OpCodes.Ldloc_0);
generator.Emit (OpCodes.Ldc_I4, iArgs); // Stores the arguments into the local variables, as needed
generator.Emit (OpCodes.Ldarg, iArgs + 1); for (int iArgs = 0, iInArgs = 1, iOutArgs = 0; iArgs < paramTypes.Length; iArgs++) {
generator.Emit (OpCodes.Ldloc_0);
if (paramTypes [iArgs].IsByRef) { generator.Emit (OpCodes.Ldc_I4, iArgs);
if (paramTypes [iArgs].GetElementType ().IsValueType) { generator.Emit (OpCodes.Ldarg, iArgs + 1);
generator.Emit (OpCodes.Ldobj, paramTypes [iArgs].GetElementType ());
generator.Emit (OpCodes.Box, paramTypes [iArgs].GetElementType ()); if (paramTypes [iArgs].IsByRef) {
} else if (paramTypes [iArgs].GetElementType ().IsValueType) {
generator.Emit (OpCodes.Ldind_Ref); generator.Emit (OpCodes.Ldobj, paramTypes [iArgs].GetElementType ());
} else { generator.Emit (OpCodes.Box, paramTypes [iArgs].GetElementType ());
if (paramTypes [iArgs].IsValueType) } else
generator.Emit (OpCodes.Box, paramTypes [iArgs]); generator.Emit (OpCodes.Ldind_Ref);
} } else {
if (paramTypes [iArgs].IsValueType)
generator.Emit (OpCodes.Stelem_Ref); generator.Emit (OpCodes.Box, paramTypes [iArgs]);
}
if (paramTypes [iArgs].IsByRef) {
generator.Emit (OpCodes.Ldloc_2); generator.Emit (OpCodes.Stelem_Ref);
generator.Emit (OpCodes.Ldc_I4, iOutArgs);
generator.Emit (OpCodes.Ldc_I4, iArgs); if (paramTypes [iArgs].IsByRef) {
generator.Emit (OpCodes.Stelem_I4); generator.Emit (OpCodes.Ldloc_2);
refArgs [iOutArgs] = iArgs; generator.Emit (OpCodes.Ldc_I4, iOutArgs);
iOutArgs++; generator.Emit (OpCodes.Ldc_I4, iArgs);
} generator.Emit (OpCodes.Stelem_I4);
refArgs [iOutArgs] = iArgs;
if (paramInfo [iArgs].IsIn || (!paramInfo [iArgs].IsOut)) { iOutArgs++;
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);
if (paramTypes [iArgs].IsByRef) { generator.Emit (OpCodes.Ldc_I4, iInArgs);
if (paramTypes [iArgs].GetElementType ().IsValueType) { generator.Emit (OpCodes.Ldarg, iArgs + 1);
generator.Emit (OpCodes.Ldobj, paramTypes [iArgs].GetElementType ());
generator.Emit (OpCodes.Box, paramTypes [iArgs].GetElementType ()); if (paramTypes [iArgs].IsByRef) {
} else if (paramTypes [iArgs].GetElementType ().IsValueType) {
generator.Emit (OpCodes.Ldind_Ref); generator.Emit (OpCodes.Ldobj, paramTypes [iArgs].GetElementType ());
} else { generator.Emit (OpCodes.Box, paramTypes [iArgs].GetElementType ());
if (paramTypes [iArgs].IsValueType) } else
generator.Emit (OpCodes.Box, paramTypes [iArgs]); generator.Emit (OpCodes.Ldind_Ref);
} } else {
if (paramTypes [iArgs].IsValueType)
generator.Emit (OpCodes.Stelem_Ref); generator.Emit (OpCodes.Box, paramTypes [iArgs]);
iInArgs++; }
}
} 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); // Gets the function the method will delegate to by calling
generator.Emit (OpCodes.Ldstr, method.Name); // the getTableFunction method of class LuaClassHelper
generator.Emit (OpCodes.Call, classHelper.GetMethod ("GetTableFunction")); generator.Emit (OpCodes.Ldarg_0);
var lab1 = generator.DefineLabel (); generator.Emit (OpCodes.Ldfld, luaTableField);
generator.Emit (OpCodes.Dup); generator.Emit (OpCodes.Ldstr, method.Name);
generator.Emit (OpCodes.Brtrue_S, lab1); generator.Emit (OpCodes.Call, classHelper.GetMethod ("GetTableFunction"));
// Function does not exist, call base method var lab1 = generator.DefineLabel ();
generator.Emit (OpCodes.Pop); generator.Emit (OpCodes.Dup);
generator.Emit (OpCodes.Brtrue_S, lab1);
if (!method.IsAbstract) { // Function does not exist, call base method
generator.Emit (OpCodes.Ldarg_0); generator.Emit (OpCodes.Pop);
for (int i = 0; i < paramTypes.Length; i++) if (!method.IsAbstract) {
generator.Emit (OpCodes.Ldarg, i + 1); generator.Emit (OpCodes.Ldarg_0);
generator.Emit (OpCodes.Call, method); for (int i = 0; i < paramTypes.Length; i++)
generator.Emit (OpCodes.Ldarg, i + 1);
if (returnType == typeof(void))
generator.Emit (OpCodes.Pop); generator.Emit (OpCodes.Call, method);
generator.Emit (OpCodes.Ret); if (returnType == typeof(void))
generator.Emit (OpCodes.Ldnull); generator.Emit (OpCodes.Pop);
} else
generator.Emit (OpCodes.Ldnull); generator.Emit (OpCodes.Ret);
generator.Emit (OpCodes.Ldnull);
var lab2 = generator.DefineLabel (); } else
generator.Emit (OpCodes.Br_S, lab2); generator.Emit (OpCodes.Ldnull);
generator.MarkLabel (lab1);
// Function exists, call using method callFunction of LuaClassHelper var lab2 = generator.DefineLabel ();
generator.Emit (OpCodes.Ldloc_0); generator.Emit (OpCodes.Br_S, lab2);
generator.Emit (OpCodes.Ldarg_0); generator.MarkLabel (lab1);
generator.Emit (OpCodes.Ldfld, returnTypesField); // Function exists, call using method callFunction of LuaClassHelper
generator.Emit (OpCodes.Ldc_I4, methodIndex); generator.Emit (OpCodes.Ldloc_0);
generator.Emit (OpCodes.Ldelem_Ref); generator.Emit (OpCodes.Ldarg_0);
generator.Emit (OpCodes.Ldloc_1); generator.Emit (OpCodes.Ldfld, returnTypesField);
generator.Emit (OpCodes.Ldloc_2); generator.Emit (OpCodes.Ldc_I4, methodIndex);
generator.Emit (OpCodes.Call, classHelper.GetMethod ("CallFunction")); generator.Emit (OpCodes.Ldelem_Ref);
generator.MarkLabel (lab2); generator.Emit (OpCodes.Ldloc_1);
generator.Emit (OpCodes.Ldloc_2);
// Stores the function return value generator.Emit (OpCodes.Call, classHelper.GetMethod ("CallFunction"));
if (returnType == typeof(void)) { generator.MarkLabel (lab2);
generator.Emit (OpCodes.Pop);
generator.Emit (OpCodes.Ldnull); // Stores the function return value
} else if (returnType.IsValueType) { if (returnType == typeof(void)) {
generator.Emit (OpCodes.Unbox, returnType); generator.Emit (OpCodes.Pop);
generator.Emit (OpCodes.Ldobj, returnType); generator.Emit (OpCodes.Ldnull);
} else } else if (returnType.IsValueType) {
generator.Emit (OpCodes.Castclass, returnType); generator.Emit (OpCodes.Unbox, returnType);
generator.Emit (OpCodes.Ldobj, returnType);
generator.Emit (OpCodes.Stloc_3); } else
generator.Emit (OpCodes.Castclass, returnType);
// Sets return values of out and ref parameters
for (int i = 0; i < refArgs.Length; i++) { generator.Emit (OpCodes.Stloc_3);
generator.Emit (OpCodes.Ldarg, refArgs [i] + 1);
generator.Emit (OpCodes.Ldloc_0); // Sets return values of out and ref parameters
generator.Emit (OpCodes.Ldc_I4, refArgs [i]); for (int i = 0; i < refArgs.Length; i++) {
generator.Emit (OpCodes.Ldelem_Ref); generator.Emit (OpCodes.Ldarg, refArgs [i] + 1);
generator.Emit (OpCodes.Ldloc_0);
if (paramTypes [refArgs [i]].GetElementType ().IsValueType) { generator.Emit (OpCodes.Ldc_I4, refArgs [i]);
generator.Emit (OpCodes.Unbox, paramTypes [refArgs [i]].GetElementType ()); generator.Emit (OpCodes.Ldelem_Ref);
generator.Emit (OpCodes.Ldobj, paramTypes [refArgs [i]].GetElementType ());
generator.Emit (OpCodes.Stobj, paramTypes [refArgs [i]].GetElementType ()); if (paramTypes [refArgs [i]].GetElementType ().IsValueType) {
} else { generator.Emit (OpCodes.Unbox, paramTypes [refArgs [i]].GetElementType ());
generator.Emit (OpCodes.Castclass, paramTypes [refArgs [i]].GetElementType ()); generator.Emit (OpCodes.Ldobj, paramTypes [refArgs [i]].GetElementType ());
generator.Emit (OpCodes.Stind_Ref); 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);
// Returns
generator.Emit (OpCodes.Ret); if (!(returnType == typeof(void)))
} generator.Emit (OpCodes.Ldloc_3);
#endif
/* generator.Emit (OpCodes.Ret);
* Gets an event handler for the event type that delegates to the eventHandler Lua function. }
* Caches the generated type. #endif
*/ /*
public LuaEventHandler GetEvent (Type eventHandlerType, LuaFunction eventHandler) * Gets an event handler for the event type that delegates to the eventHandler Lua function.
{ * Caches the generated type.
#if MONOTOUCH */
throw new NotImplementedException (" Emit not available on MonoTouch "); public LuaEventHandler GetEvent (Type eventHandlerType, LuaFunction eventHandler)
#elif SILVERLIGHT {
throw new NotImplementedException (" Emit not available on Silverlight "); #if MONOTOUCH
#elif NETFX_CORE throw new NotImplementedException (" Emit not available on MonoTouch ");
throw new NotImplementedException (" Emit not available on Windows Store "); #elif SILVERLIGHT
#else throw new NotImplementedException (" Emit not available on Silverlight ");
Type eventConsumerType; #elif NETFX_CORE
throw new NotImplementedException (" Emit not available on Windows Store ");
if (eventHandlerCollection.ContainsKey (eventHandlerType)) #else
eventConsumerType = eventHandlerCollection [eventHandlerType]; Type eventConsumerType;
else {
eventConsumerType = GenerateEvent (eventHandlerType); if (eventHandlerCollection.ContainsKey (eventHandlerType))
eventHandlerCollection [eventHandlerType] = eventConsumerType; eventConsumerType = eventHandlerCollection [eventHandlerType];
} else {
eventConsumerType = GenerateEvent (eventHandlerType);
var luaEventHandler = (LuaEventHandler)Activator.CreateInstance (eventConsumerType); eventHandlerCollection [eventHandlerType] = eventConsumerType;
luaEventHandler.handler = eventHandler; }
return luaEventHandler;
#endif var luaEventHandler = (LuaEventHandler)Activator.CreateInstance (eventConsumerType);
} luaEventHandler.handler = eventHandler;
return luaEventHandler;
public void RegisterLuaDelegateType (Type delegateType, Type luaDelegateType) #endif
{ }
delegateCollection [delegateType] = luaDelegateType;
} public void RegisterLuaDelegateType (Type delegateType, Type luaDelegateType)
{
public void RegisterLuaClassType (Type klass, Type luaClass) delegateCollection [delegateType] = luaDelegateType;
{ }
LuaClassType luaClassType = new LuaClassType ();
luaClassType.klass = luaClass; public void RegisterLuaClassType (Type klass, Type luaClass)
GetReturnTypesFromClass (klass, out luaClassType.returnTypes); {
classCollection [klass] = luaClassType; LuaClassType luaClassType = new LuaClassType ();
} luaClassType.klass = luaClass;
/* GetReturnTypesFromClass (klass, out luaClassType.returnTypes);
* Gets a delegate with delegateType that calls the luaFunc Lua function classCollection [klass] = luaClassType;
* Caches the generated type. }
*/ /*
public Delegate GetDelegate (Type delegateType, LuaFunction luaFunc) * Gets a delegate with delegateType that calls the luaFunc Lua function
{ * Caches the generated type.
var returnTypes = new List<Type> (); */
Type luaDelegateType; public Delegate GetDelegate (Type delegateType, LuaFunction luaFunc)
{
if (delegateCollection.ContainsKey (delegateType)) var returnTypes = new List<Type> ();
luaDelegateType = delegateCollection [delegateType]; Type luaDelegateType;
else {
luaDelegateType = GenerateDelegate (delegateType); if (delegateCollection.ContainsKey (delegateType))
delegateCollection [delegateType] = luaDelegateType; luaDelegateType = delegateCollection [delegateType];
} else {
luaDelegateType = GenerateDelegate (delegateType);
var methodInfo = delegateType.GetMethod ("Invoke"); delegateCollection [delegateType] = luaDelegateType;
returnTypes.Add (methodInfo.ReturnType); }
foreach (ParameterInfo paramInfo in methodInfo.GetParameters()) { var methodInfo = delegateType.GetMethod ("Invoke");
if (paramInfo.ParameterType.IsByRef) returnTypes.Add (methodInfo.ReturnType);
returnTypes.Add (paramInfo.ParameterType);
} foreach (ParameterInfo paramInfo in methodInfo.GetParameters()) {
if (paramInfo.ParameterType.IsByRef)
var luaDelegate = (LuaDelegate)Activator.CreateInstance (luaDelegateType); returnTypes.Add (paramInfo.ParameterType);
luaDelegate.function = luaFunc; }
luaDelegate.returnTypes = returnTypes.ToArray ();
#if NETFX_CORE var luaDelegate = (LuaDelegate)Activator.CreateInstance (luaDelegateType);
var mi = luaDelegate.GetType ().GetTypeInfo ().GetDeclaredMethod ("CallFunction"); luaDelegate.function = luaFunc;
return mi.CreateDelegate (delegateType, luaDelegate); luaDelegate.returnTypes = returnTypes.ToArray ();
#else #if NETFX_CORE
return Delegate.CreateDelegate (delegateType, luaDelegate, "CallFunction"); var mi = luaDelegate.GetType ().GetTypeInfo ().GetDeclaredMethod ("CallFunction");
#endif return mi.CreateDelegate (delegateType, luaDelegate);
} #else
return Delegate.CreateDelegate (delegateType, luaDelegate, "CallFunction");
/* #endif
* Gets an instance of an implementation of the klass interface or }
* subclass of klass that delegates public virtual methods to the
* luaTable table. /*
* Caches the generated type. * Gets an instance of an implementation of the klass interface or
*/ * subclass of klass that delegates public virtual methods to the
public object GetClassInstance (Type klass, LuaTable luaTable) * luaTable table.
{ * Caches the generated type.
LuaClassType luaClassType; */
public object GetClassInstance (Type klass, LuaTable luaTable)
if (classCollection.ContainsKey (klass)) {
luaClassType = classCollection [klass]; LuaClassType luaClassType;
else {
luaClassType = new LuaClassType (); if (classCollection.ContainsKey (klass))
GenerateClass (klass, out luaClassType.klass, out luaClassType.returnTypes); luaClassType = classCollection [klass];
classCollection [klass] = luaClassType; else {
} luaClassType = new LuaClassType ();
GenerateClass (klass, out luaClassType.klass, out luaClassType.returnTypes);
return Activator.CreateInstance (luaClassType.klass, new object[] { classCollection [klass] = luaClassType;
luaTable, }
luaClassType.returnTypes
}); return Activator.CreateInstance (luaClassType.klass, new object[] {
} luaTable,
} luaClassType.returnTypes
});
}
}
} }
\ No newline at end of file
...@@ -635,12 +635,12 @@ end ...@@ -635,12 +635,12 @@ end
#endregion #endregion
#region Properties #region Properties
foreach (var property in type.GetProperties(BindingFlags.Public | BindingFlags.Instance)) { foreach (var property in type.GetProperties (BindingFlags.Public | BindingFlags.Instance)) {
if ( if (
// Check that the LuaHideAttribute and LuaGlobalAttribute were not applied // Check that the LuaHideAttribute and LuaGlobalAttribute were not applied
(!property.GetCustomAttributes (typeof(LuaHideAttribute), false).Any ()) && (!property.GetCustomAttributes (typeof(LuaHideAttribute), false).Any ()) &&
(!property.GetCustomAttributes (typeof(LuaGlobalAttribute), false).Any ()) (!property.GetCustomAttributes (typeof(LuaGlobalAttribute), false).Any ())
// Exclude some generic .NET properties that wouldn't be very usefull in Lua // Exclude some generic .NET properties that wouldn't be very useful in Lua
&& property.Name != "Item") { && property.Name != "Item") {
// Go into recursion for members // Go into recursion for members
RegisterGlobal (path + "." + property.Name, property.PropertyType, recursionCounter + 1); RegisterGlobal (path + "." + property.Name, property.PropertyType, recursionCounter + 1);
...@@ -969,8 +969,8 @@ end ...@@ -969,8 +969,8 @@ end
{ {
#elif NETFX_CORE #elif NETFX_CORE
static void DebugHookCallback (LuaState luaState, long luaDebug) static void DebugHookCallback (LuaState luaState, long luaDebug)
{ {
IntPtr ptr = new IntPtr (luaDebug); IntPtr ptr = new IntPtr (luaDebug);
LuaDebug debug = System.Runtime.InteropServices.Marshal.PtrToStructure <LuaDebug> (ptr); LuaDebug debug = System.Runtime.InteropServices.Marshal.PtrToStructure <LuaDebug> (ptr);
#else #else
static void DebugHookCallback (LuaState luaState, IntPtr luaDebug) static void DebugHookCallback (LuaState luaState, IntPtr luaDebug)
......
...@@ -33,7 +33,6 @@ using NLua.Method; ...@@ -33,7 +33,6 @@ using NLua.Method;
using NLua.Exceptions; using NLua.Exceptions;
using NLua.Extensions; using NLua.Extensions;
namespace NLua namespace NLua
{ {
#if USE_KOPILUA #if USE_KOPILUA
...@@ -280,13 +279,13 @@ namespace NLua ...@@ -280,13 +279,13 @@ namespace NLua
assembly = Assembly.Load (new AssemblyName (assemblyName)); assembly = Assembly.Load (new AssemblyName (assemblyName));
#else #else
assembly = Assembly.Load (assemblyName); assembly = Assembly.Load (assemblyName);
#endif #endif
} catch (BadImageFormatException) { } catch (BadImageFormatException) {
// The assemblyName was invalid. It is most likely a path. // The assemblyName was invalid. It is most likely a path.
} catch (FileNotFoundException e) { } catch (FileNotFoundException e) {
exception = e; exception = e;
} }
#if !SILVERLIGHT && !NETFX_CORE #if !SILVERLIGHT && !NETFX_CORE
if (assembly == null) { if (assembly == null) {
try { try {
...@@ -311,7 +310,7 @@ namespace NLua ...@@ -311,7 +310,7 @@ namespace NLua
if (exception != null) if (exception != null)
ThrowError (luaState, exception); ThrowError (luaState, exception);
} }
#endif #endif
if (assembly != null && !assemblies.Contains (assembly)) if (assembly != null && !assemblies.Contains (assembly))
assemblies.Add (assembly); assemblies.Add (assembly);
} catch (Exception e) { } catch (Exception e) {
...@@ -752,7 +751,7 @@ namespace NLua ...@@ -752,7 +751,7 @@ namespace NLua
if (!o.GetType ().GetTypeInfo ().IsValueType) if (!o.GetType ().GetTypeInfo ().IsValueType)
#else #else
if (!o.GetType ().IsValueType) if (!o.GetType ().IsValueType)
#endif #endif
objectsBackMap.Remove (o); objectsBackMap.Remove (o);
} }
...@@ -761,12 +760,12 @@ namespace NLua ...@@ -761,12 +760,12 @@ namespace NLua
// New object: inserts it in the list // New object: inserts it in the list
int index = nextObj++; int index = nextObj++;
objects [index] = obj; objects [index] = obj;
#if NETFX_CORE #if NETFX_CORE
if (!obj.GetType ().GetTypeInfo().IsValueType) if (!obj.GetType ().GetTypeInfo().IsValueType)
#else #else
if (!obj.GetType().IsValueType) if (!obj.GetType().IsValueType)
#endif #endif
objectsBackMap [obj] = index; objectsBackMap [obj] = index;
return index; return index;
} }
...@@ -914,7 +913,11 @@ namespace NLua ...@@ -914,7 +913,11 @@ namespace NLua
if (o is ILuaGeneratedType) { if (o is ILuaGeneratedType) {
// Make sure we are _really_ ILuaGenerated // Make sure we are _really_ ILuaGenerated
var typ = o.GetType (); var typ = o.GetType ();
#if NETFX_CORE
return typ.ImplementInterface ("ILuaGeneratedType");
#else
return typ.GetInterface ("ILuaGeneratedType", true) != null; return typ.GetInterface ("ILuaGeneratedType", true) != null;
#endif
} }
return false; return false;
} }
......
/* /*
* This file is part of NLua. * This file is part of NLua.
* *
* Copyright (c) 2014 Vinicius Jarina (viniciusjarina@gmail.com) * Copyright (c) 2014 Vinicius Jarina (viniciusjarina@gmail.com)
* Copyright (C) 2003-2005 Fabio Mascarenhas de Queiroz. * Copyright (C) 2003-2005 Fabio Mascarenhas de Queiroz.
* Copyright (C) 2012 Megax <http://megax.yeahunter.hu/> * Copyright (C) 2012 Megax <http://megax.yeahunter.hu/>
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal * of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights * in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is * copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions: * furnished to do so, subject to the following conditions:
* *
* The above copyright notice and this permission notice shall be included in * The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software. * all copies or substantial portions of the Software.
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE. * THE SOFTWARE.
*/ */
using System; using System;
using System.Globalization; using System.Globalization;
using System.Reflection; using System.Reflection;
namespace NLua #if NETFX_CORE
{ using NLua.Extensions;
/// <summary> #endif
/// Summary description for ProxyType.
/// </summary> namespace NLua
public class ProxyType {
{ /// <summary>
private Type proxy; /// Summary description for ProxyType.
/// </summary>
public ProxyType (Type proxy) public class ProxyType
{ {
this.proxy = proxy; private Type proxy;
}
public ProxyType (Type proxy)
/// <summary> {
/// Provide human readable short hand for this proxy object this.proxy = proxy;
/// </summary> }
/// <returns></returns>
public override string ToString () /// <summary>
{ /// Provide human readable short hand for this proxy object
return "ProxyType(" + UnderlyingSystemType + ")"; /// </summary>
} /// <returns></returns>
public override string ToString ()
public Type UnderlyingSystemType { {
get { return proxy; } return "ProxyType(" + UnderlyingSystemType + ")";
} }
public override bool Equals (object obj) public Type UnderlyingSystemType {
{ get { return proxy; }
if (obj is Type) }
return proxy.Equals ((Type)obj);
if (obj is ProxyType) public override bool Equals (object obj)
return proxy.Equals (((ProxyType)obj).UnderlyingSystemType); {
return proxy.Equals (obj); if (obj is Type)
} return proxy.Equals ((Type)obj);
if (obj is ProxyType)
public override int GetHashCode () return proxy.Equals (((ProxyType)obj).UnderlyingSystemType);
{ return proxy.Equals (obj);
return proxy.GetHashCode (); }
}
public override int GetHashCode ()
public MemberInfo[] GetMember (string name, BindingFlags bindingAttr) {
{ return proxy.GetHashCode ();
return proxy.GetMember (name, bindingAttr); }
}
public MemberInfo[] GetMember (string name, BindingFlags bindingAttr)
public MethodInfo GetMethod (string name, BindingFlags bindingAttr, Type[] signature) {
{ return proxy.GetMember (name, bindingAttr);
return proxy.GetMethod (name, bindingAttr, null, signature, null); }
}
} public MethodInfo GetMethod (string name, BindingFlags bindingAttr, Type[] signature)
{
#if NETFX_CORE
return proxy.GetMethod (name, bindingAttr, signature);
#else
return proxy.GetMethod (name, bindingAttr, null, signature, null);
#endif
}
}
} }
\ No newline at end of file
 
Microsoft Visual Studio Solution File, Format Version 12.00 Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013 # Visual Studio 2013
VisualStudioVersion = 12.0.30723.0 VisualStudioVersion = 12.0.30723.0
MinimumVisualStudioVersion = 10.0.40219.1 MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lua52", "Core\KeraLua\external\lua\wp8_build\lua\lua52\lua52.vcxproj", "{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}" Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lua52", "Core\KeraLua\external\lua\wp8_build\lua\lua52\lua52.vcxproj", "{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}"
EndProject EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "KeraLua.WP8", "Core\KeraLua\src\WP8\KeraLua.WP8.csproj", "{1F139CCB-195B-402D-8776-7A15A3E05886}" Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "KeraLua.WP8", "Core\KeraLua\src\WP8\KeraLua.WP8.csproj", "{1F139CCB-195B-402D-8776-7A15A3E05886}"
EndProject EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NLua.WP8", "Core\NLua\NLua.WP8.csproj", "{1E72B073-2154-4329-BC8D-94F19F91C945}" Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NLua.WP8", "Core\NLua\NLua.WP8.csproj", "{1E72B073-2154-4329-BC8D-94F19F91C945}"
EndProject EndProject
Global Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU Debug|Any CPU = Debug|Any CPU
Debug|ARM = Debug|ARM Debug|ARM = Debug|ARM
Debug|Mixed Platforms = Debug|Mixed Platforms Debug|Mixed Platforms = Debug|Mixed Platforms
Debug|Win32 = Debug|Win32 Debug|Win32 = Debug|Win32
Debug|x86 = Debug|x86 Debug|x86 = Debug|x86
Release|Any CPU = Release|Any CPU Release|Any CPU = Release|Any CPU
Release|ARM = Release|ARM Release|ARM = Release|ARM
Release|Mixed Platforms = Release|Mixed Platforms Release|Mixed Platforms = Release|Mixed Platforms
Release|Win32 = Release|Win32 Release|Win32 = Release|Win32
Release|x86 = Release|x86 Release|x86 = Release|x86
EndGlobalSection EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution GlobalSection(ProjectConfigurationPlatforms) = postSolution
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|Any CPU.ActiveCfg = Debug|Win32 {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|Any CPU.ActiveCfg = Debug|Win32
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|ARM.ActiveCfg = Debug|ARM {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|ARM.ActiveCfg = Debug|ARM
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|ARM.Build.0 = Debug|ARM {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|ARM.Build.0 = Debug|ARM
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32 {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|Mixed Platforms.Build.0 = Debug|Win32 {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|Mixed Platforms.Build.0 = Debug|Win32
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|Win32.ActiveCfg = Debug|Win32 {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|Win32.ActiveCfg = Debug|Win32
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|Win32.Build.0 = Debug|Win32 {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|Win32.Build.0 = Debug|Win32
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|x86.ActiveCfg = Debug|Win32 {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|x86.ActiveCfg = Debug|Win32
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|x86.Build.0 = Debug|Win32 {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Debug|x86.Build.0 = Debug|Win32
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|Any CPU.ActiveCfg = Release|Win32 {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|Any CPU.ActiveCfg = Release|Win32
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|ARM.ActiveCfg = Release|ARM {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|ARM.ActiveCfg = Release|ARM
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|ARM.Build.0 = Release|ARM {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|ARM.Build.0 = Release|ARM
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|Mixed Platforms.ActiveCfg = Release|Win32 {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|Mixed Platforms.ActiveCfg = Release|Win32
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|Mixed Platforms.Build.0 = Release|Win32 {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|Mixed Platforms.Build.0 = Release|Win32
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|Win32.ActiveCfg = Release|Win32 {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|Win32.ActiveCfg = Release|Win32
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|Win32.Build.0 = Release|Win32 {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|Win32.Build.0 = Release|Win32
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|x86.ActiveCfg = Release|Win32 {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|x86.ActiveCfg = Release|Win32
{51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|x86.Build.0 = Release|Win32 {51334677-A80F-40F7-8CFE-5DA0A92AC0C6}.Release|x86.Build.0 = Release|Win32
{1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|Any CPU.Build.0 = Debug|Any CPU {1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|Any CPU.Build.0 = Debug|Any CPU
{1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|ARM.ActiveCfg = Debug|ARM {1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|ARM.ActiveCfg = Debug|ARM
{1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|ARM.Build.0 = Debug|ARM {1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|ARM.Build.0 = Debug|ARM
{1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|Mixed Platforms.ActiveCfg = Debug|x86 {1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
{1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|Mixed Platforms.Build.0 = Debug|x86 {1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|Mixed Platforms.Build.0 = Debug|x86
{1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|Win32.ActiveCfg = Debug|x86 {1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|Win32.ActiveCfg = Debug|x86
{1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|Win32.Build.0 = Debug|x86 {1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|Win32.Build.0 = Debug|x86
{1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|x86.ActiveCfg = Debug|x86 {1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|x86.ActiveCfg = Debug|x86
{1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|x86.Build.0 = Debug|x86 {1F139CCB-195B-402D-8776-7A15A3E05886}.Debug|x86.Build.0 = Debug|x86
{1F139CCB-195B-402D-8776-7A15A3E05886}.Release|Any CPU.ActiveCfg = Release|Any CPU {1F139CCB-195B-402D-8776-7A15A3E05886}.Release|Any CPU.ActiveCfg = Release|Any CPU
{1F139CCB-195B-402D-8776-7A15A3E05886}.Release|Any CPU.Build.0 = Release|Any CPU {1F139CCB-195B-402D-8776-7A15A3E05886}.Release|Any CPU.Build.0 = Release|Any CPU
{1F139CCB-195B-402D-8776-7A15A3E05886}.Release|ARM.ActiveCfg = Release|ARM {1F139CCB-195B-402D-8776-7A15A3E05886}.Release|ARM.ActiveCfg = Release|ARM
{1F139CCB-195B-402D-8776-7A15A3E05886}.Release|ARM.Build.0 = Release|ARM {1F139CCB-195B-402D-8776-7A15A3E05886}.Release|ARM.Build.0 = Release|ARM
{1F139CCB-195B-402D-8776-7A15A3E05886}.Release|Mixed Platforms.ActiveCfg = Release|x86 {1F139CCB-195B-402D-8776-7A15A3E05886}.Release|Mixed Platforms.ActiveCfg = Release|x86
{1F139CCB-195B-402D-8776-7A15A3E05886}.Release|Mixed Platforms.Build.0 = Release|x86 {1F139CCB-195B-402D-8776-7A15A3E05886}.Release|Mixed Platforms.Build.0 = Release|x86
{1F139CCB-195B-402D-8776-7A15A3E05886}.Release|Win32.ActiveCfg = Release|x86 {1F139CCB-195B-402D-8776-7A15A3E05886}.Release|Win32.ActiveCfg = Release|x86
{1F139CCB-195B-402D-8776-7A15A3E05886}.Release|Win32.Build.0 = Release|x86 {1F139CCB-195B-402D-8776-7A15A3E05886}.Release|Win32.Build.0 = Release|x86
{1F139CCB-195B-402D-8776-7A15A3E05886}.Release|x86.ActiveCfg = Release|x86 {1F139CCB-195B-402D-8776-7A15A3E05886}.Release|x86.ActiveCfg = Release|x86
{1F139CCB-195B-402D-8776-7A15A3E05886}.Release|x86.Build.0 = Release|x86 {1F139CCB-195B-402D-8776-7A15A3E05886}.Release|x86.Build.0 = Release|x86
{1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|Any CPU.Build.0 = Debug|Any CPU {1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|Any CPU.Build.0 = Debug|Any CPU
{1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|ARM.ActiveCfg = Debug|ARM {1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|ARM.ActiveCfg = Debug|ARM
{1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|ARM.Build.0 = Debug|ARM {1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|ARM.Build.0 = Debug|ARM
{1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|Mixed Platforms.ActiveCfg = Debug|x86 {1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|Mixed Platforms.ActiveCfg = Debug|x86
{1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|Mixed Platforms.Build.0 = Debug|x86 {1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|Mixed Platforms.Build.0 = Debug|x86
{1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|Win32.ActiveCfg = Debug|x86 {1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|Win32.ActiveCfg = Debug|x86
{1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|Win32.Build.0 = Debug|x86 {1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|Win32.Build.0 = Debug|x86
{1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|x86.ActiveCfg = Debug|x86 {1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|x86.ActiveCfg = Debug|x86
{1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|x86.Build.0 = Debug|x86 {1E72B073-2154-4329-BC8D-94F19F91C945}.Debug|x86.Build.0 = Debug|x86
{1E72B073-2154-4329-BC8D-94F19F91C945}.Release|Any CPU.ActiveCfg = Release|Any CPU {1E72B073-2154-4329-BC8D-94F19F91C945}.Release|Any CPU.ActiveCfg = Release|Any CPU
{1E72B073-2154-4329-BC8D-94F19F91C945}.Release|Any CPU.Build.0 = Release|Any CPU {1E72B073-2154-4329-BC8D-94F19F91C945}.Release|Any CPU.Build.0 = Release|Any CPU
{1E72B073-2154-4329-BC8D-94F19F91C945}.Release|ARM.ActiveCfg = Release|ARM {1E72B073-2154-4329-BC8D-94F19F91C945}.Release|ARM.ActiveCfg = Release|ARM
{1E72B073-2154-4329-BC8D-94F19F91C945}.Release|ARM.Build.0 = Release|ARM {1E72B073-2154-4329-BC8D-94F19F91C945}.Release|ARM.Build.0 = Release|ARM
{1E72B073-2154-4329-BC8D-94F19F91C945}.Release|Mixed Platforms.ActiveCfg = Release|x86 {1E72B073-2154-4329-BC8D-94F19F91C945}.Release|Mixed Platforms.ActiveCfg = Release|x86
{1E72B073-2154-4329-BC8D-94F19F91C945}.Release|Mixed Platforms.Build.0 = Release|x86 {1E72B073-2154-4329-BC8D-94F19F91C945}.Release|Mixed Platforms.Build.0 = Release|x86
{1E72B073-2154-4329-BC8D-94F19F91C945}.Release|Win32.ActiveCfg = Release|x86 {1E72B073-2154-4329-BC8D-94F19F91C945}.Release|Win32.ActiveCfg = Release|x86
{1E72B073-2154-4329-BC8D-94F19F91C945}.Release|Win32.Build.0 = Release|x86 {1E72B073-2154-4329-BC8D-94F19F91C945}.Release|Win32.Build.0 = Release|x86
{1E72B073-2154-4329-BC8D-94F19F91C945}.Release|x86.ActiveCfg = Release|x86 {1E72B073-2154-4329-BC8D-94F19F91C945}.Release|x86.ActiveCfg = Release|x86
{1E72B073-2154-4329-BC8D-94F19F91C945}.Release|x86.Build.0 = Release|x86 {1E72B073-2154-4329-BC8D-94F19F91C945}.Release|x86.Build.0 = Release|x86
EndGlobalSection EndGlobalSection
GlobalSection(SolutionProperties) = preSolution GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE HideSolutionNode = FALSE
EndGlobalSection EndGlobalSection
EndGlobal EndGlobal
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