void AddOverloadedMethod2(Script s, string name)
{
var ov = new OverloadedMethodMemberDescriptor(name, Type);
var mr = Type.GetMethods(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
.Where(mi => mi.Name == name).ToArray();
vars.Add(DynValue.NewString(name), DynValue.NewCallback(new CallbackFunction(new Func <ScriptExecutionContext, CallbackArguments, DynValue>((sc, a) => {
try
{
var args = a.GetArray().Select(ff => ff.ToObject()).ToArray();
var atypes = args.Skip(1).Select(ff => ff.GetType()).ToArray();
var m = Type.GetMethod(name, atypes); //Soo slow
if (m != null)
{
return(DynValue.FromObject(sc.OwnerScript, m.Invoke(args[0], args.Skip(1).ToArray())));
}
return(DynValue.Nil);
}
catch (Exception e)
{
sc.OwnerScript.DoString("print('error '.." + e.Message + ") print('at '..debug.traceback())");
return(DynValue.Nil);
}
}))));
}
public void OverloadTest_WithoutObjects()
{
Script s = new Script();
// Create an instance of the overload resolver
var ov = new OverloadedMethodMemberDescriptor("Method1", this.GetType());
// Iterate over the two methods through reflection
foreach (var method in this.GetType().GetMethods(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
.Where(mi => mi.Name == "Method1"))
{
ov.AddOverload(new MethodMemberDescriptor(method));
}
// Creates the callback over the 'this' object
DynValue callback = DynValue.NewCallback(ov.GetCallbackFunction(s, this));
s.Globals.Set("func", callback);
// Execute and check the results.
DynValue result = s.DoString("return func(), func(17)");
Assert.AreEqual(DataType.Tuple, result.Type);
Assert.AreEqual(DataType.Number, result.Tuple[0].Type);
Assert.AreEqual(DataType.Number, result.Tuple[1].Type);
Assert.AreEqual(1, result.Tuple[0].Number);
Assert.AreEqual(22, result.Tuple[1].Number);
}
void AddOverloadedMethod(Script s, string name)
{
var ov = new OverloadedMethodMemberDescriptor(name, Type);
foreach (var method in Type.GetMethods(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
.Where(mi => mi.Name == name))
{
ov.AddOverload(new MethodMemberDescriptor(method));
}
vars.Add(DynValue.NewString(name), DynValue.NewCallback(ov.GetCallbackFunction(s)));
}
/// <summary>
/// Tries to perform an indexing operation by checking newly added extension methods for the given indexName.
/// </summary>
/// <param name="script">The script.</param>
/// <param name="obj">The object.</param>
/// <param name="indexName">Member name to be indexed.</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException"></exception>
private DynValue TryIndexOnExtMethod(Script script, object obj, string indexName)
{
List <IOverloadableMemberDescriptor> methods = UserData.GetExtensionMethodsByNameAndType(indexName, this.Type);
if (methods != null && methods.Count > 0)
{
var ext = new OverloadedMethodMemberDescriptor(indexName, this.Type);
ext.SetExtensionMethodsSnapshot(UserData.GetExtensionMethodsChangeVersion(), methods);
m_Members.Add(indexName, ext);
return(DynValue.NewCallback(ext.GetCallback(script, obj)));
}
return(null);
}
/// <summary>
/// Initializes a new instance of the <see cref="Script"/> class.
/// </summary>
/// <param name="coreModules">The core modules to be pre-registered in the default global table.</param>
public Script(CoreModules coreModules)
{
Options = new ScriptOptions(DefaultOptions);
PerformanceStats = new PerformanceStatistics();
Registry = new Table(this);
m_ByteCode = new ByteCode(this);
m_MainProcessor = new Processor(this, m_GlobalTable, m_ByteCode);
m_GlobalTable = new Table(this).RegisterCoreModules(coreModules);
foreach (var t in TypeDescriptorRegistry.RegisteredTypes)
{
Type valType = t.Value.Type;
if (valType.GetTypeInfo().Assembly.FullName != typeof(Script).GetTypeInfo().Assembly.FullName)
{
// m_GlobalTable.RegisterModuleType(t.Value.Type);
if (t.Value is StandardUserDataDescriptor)
{
StandardUserDataDescriptor desc = (StandardUserDataDescriptor)t.Value;
foreach (var member in desc.Members)
{
if (member.Value is MethodMemberDescriptor)
{
MethodMemberDescriptor methDesc = (MethodMemberDescriptor)member.Value;
if (methDesc.IsConstructor)
{
m_GlobalTable.Set(methDesc.Name, methDesc.GetCallbackAsDynValue(this));
}
}
else if (member.Value is OverloadedMethodMemberDescriptor)
{
OverloadedMethodMemberDescriptor methDesc = (OverloadedMethodMemberDescriptor)member.Value;
foreach (var overloadDesc in methDesc.m_Overloads)
{
if (overloadDesc is MethodMemberDescriptor)
{
MethodMemberDescriptor actualDesc = (MethodMemberDescriptor)overloadDesc;
if (actualDesc.IsConstructor)
{
//m_GlobalTable.Set(desc.FriendlyName, actualDesc.GetCallbackAsDynValue(this));
m_GlobalTable.Set(desc.FriendlyName, DynValue.NewCallback(methDesc.GetCallbackFunction(this)));
break;
}
}
}
}
}
}
}
}
}
private void AddMemberTo(Dictionary <string, IMemberDescriptor> members, string name, IMemberDescriptor desc)
{
IOverloadableMemberDescriptor odesc = desc as IOverloadableMemberDescriptor;
if (odesc != null)
{
if (members.ContainsKey(name))
{
OverloadedMethodMemberDescriptor overloads = members[name] as OverloadedMethodMemberDescriptor;
if (overloads != null)
{
overloads.AddOverload(odesc);
}
else
{
throw new ArgumentException(string.Format("Multiple members named {0} are being added to type {1} and one or more of these members do not support overloads.", name, this.Type.FullName));
}
}
else
{
members.Add(name, new OverloadedMethodMemberDescriptor(name, this.Type, odesc));
}
}
else
{
if (members.ContainsKey(name))
{
throw new ArgumentException(string.Format("Multiple members named {0} are being added to type {1} and one or more of these members do not support overloads.", name, this.Type.FullName));
}
else
{
members.Add(name, desc);
}
}
}
/// <summary>
/// Tries to perform an indexing operation by checking newly added extension methods for the given indexName.
/// </summary>
/// <param name="script">The script.</param>
/// <param name="obj">The object.</param>
/// <param name="indexName">Member name to be indexed.</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException"></exception>
private DynValue TryIndexOnExtMethod(Script script, object obj, string indexName)
{
List<IOverloadableMemberDescriptor> methods = UserData.GetExtensionMethodsByNameAndType(indexName, this.Type);
if (methods != null && methods.Count > 0)
{
var ext = new OverloadedMethodMemberDescriptor(indexName, this.Type);
ext.SetExtensionMethodsSnapshot(UserData.GetExtensionMethodsChangeVersion(), methods);
m_Members.Add(indexName, ext);
return DynValue.NewCallback(ext.GetCallback(script, obj));
}
return null;
}
public void OverloadTest_WithoutObjects()
{
Script s = new Script();
// Create an instance of the overload resolver
var ov = new OverloadedMethodMemberDescriptor("Method1", this.GetType());
// Iterate over the two methods through reflection
foreach(var method in this.GetType().GetMethods(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
.Where(mi => mi.Name == "Method1"))
{
ov.AddOverload(new MethodMemberDescriptor(method));
}
// Creates the callback over the 'this' object
DynValue callback = DynValue.NewCallback(ov.GetCallbackFunction(s, this));
s.Globals.Set("func", callback);
// Execute and check the results.
DynValue result = s.DoString("return func(), func(17)");
Assert.AreEqual(DataType.Tuple, result.Type);
Assert.AreEqual(DataType.Number, result.Tuple[0].Type);
Assert.AreEqual(DataType.Number, result.Tuple[1].Type);
Assert.AreEqual(1, result.Tuple[0].Number);
Assert.AreEqual(22, result.Tuple[1].Number);
}
