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); }