/// <summary> /// The internal callback which actually executes the method /// </summary> /// <param name="script">The script.</param> /// <param name="obj">The object.</param> /// <param name="context">The context.</param> /// <param name="args">The arguments.</param> public override DynValue Execute(Script script, object obj, ScriptExecutionContext context, CallbackArguments args) { if (m_CallbackFunc != null) { var retv = m_CallbackFunc(obj, context, args); return(ClrToScriptConversions.ObjectToDynValue(script, retv)); } return(DynValue.Void); }
/// <summary> /// Builds the return value of a call /// </summary> /// <param name="script">The script.</param> /// <param name="outParams">The out parameters indices, or null. See <see cref="BuildArgumentList" />.</param> /// <param name="pars">The parameters passed to the function.</param> /// <param name="retv">The return value from the function. Use DynValue.Void if the function returned no value.</param> /// <returns>A DynValue to be returned to scripts</returns> protected static DynValue BuildReturnValue(Script script, List <int> outParams, object[] pars, object retv) { if (outParams == null) { return(ClrToScriptConversions.ObjectToDynValue(script, retv)); } var rets = new DynValue[outParams.Count + 1]; if (retv is DynValue value && value.IsVoid()) { rets[0] = DynValue.Nil; }
public static DynValue TaskResultToDynValue(Script script, Task task) { var voidTaskType = typeof(Task <>).MakeGenericType(Type.GetType("System.Threading.Tasks.VoidTaskResult")); if (voidTaskType.IsAssignableFrom(task.GetType())) { return(DynValue.Nil); //no return type } var property = task.GetType().GetProperty("Result", BindingFlags.Public | BindingFlags.Instance); if (property == null) { return(DynValue.Nil); } return(ClrToScriptConversions.ObjectToDynValue(script, property.GetValue(task))); }
private DynValue GetNext(DynValue prev) { if (prev.IsNil()) { Reset(); } while (m_Enumerator.MoveNext()) { DynValue v = ClrToScriptConversions.ObjectToDynValue(m_Script, m_Enumerator.Current); if (!v.IsNil()) { return(v); } } return(DynValue.Nil); }
/// <summary> /// Gets the value of the property /// </summary> /// <param name="script">The script.</param> /// <param name="obj">The object.</param> /// <returns></returns> public DynValue GetValue(Script script, object obj) { this.CheckAccess(MemberDescriptorAccess.CanRead, obj); // optimization+workaround of Unity bug.. if (IsConst) return ClrToScriptConversions.ObjectToDynValue(script, m_ConstValue); if (AccessMode == InteropAccessMode.LazyOptimized && m_OptimizedGetter == null) OptimizeGetter(); object result = null; if (m_OptimizedGetter != null) result = m_OptimizedGetter(obj); else result = FieldInfo.GetValue(obj); return ClrToScriptConversions.ObjectToDynValue(script, result); }
/// <summary> /// Gets the value of the property /// </summary> /// <param name="script">The script.</param> /// <param name="obj">The object.</param> /// <returns></returns> public DynValue GetValue(Script script, object obj) { if (m_Getter == null) { throw new ScriptRuntimeException("userdata property '{0}.{1}' cannot be read from.", this.PropertyInfo.DeclaringType.Name, this.Name); } if (AccessMode == InteropAccessMode.LazyOptimized && m_OptimizedGetter == null) { OptimizeGetter(); } object result = null; if (m_OptimizedGetter != null) { result = m_OptimizedGetter(obj); } else { result = m_Getter.Invoke(IsStatic ? null : obj, null); // convoluted workaround for --full-aot Mono execution } return(ClrToScriptConversions.ObjectToDynValue(script, result)); }
/// <summary> /// The internal callback which actually executes the method /// </summary> /// <param name="script">The script.</param> /// <param name="obj">The object.</param> /// <param name="context">The context.</param> /// <param name="args">The arguments.</param> /// <returns></returns> internal DynValue Callback(Script script, object obj, ScriptExecutionContext context, CallbackArguments args) { if (ValueTypeDefaultCtor != null) { object vto = Activator.CreateInstance(ValueTypeDefaultCtor); return(ClrToScriptConversions.ObjectToDynValue(script, vto)); } if (AccessMode == InteropAccessMode.LazyOptimized && m_OptimizedFunc == null && m_OptimizedAction == null) { Optimize(); } object[] pars = new object[Parameters.Length]; int j = args.IsMethodCall ? 1 : 0; List <int> outParams = null; for (int i = 0; i < pars.Length; i++) { // keep track of out and ref params if (Parameters[i].ParameterType.IsByRef) { if (outParams == null) { outParams = new List <int>(); } outParams.Add(i); } // if an ext method, we have an obj -> fill the first param if (ExtensionMethodType != null && obj != null && i == 0) { pars[i] = obj; continue; } // else, fill types with a supported type else if (Parameters[i].ParameterType == typeof(Script)) { pars[i] = script; } else if (Parameters[i].ParameterType == typeof(ScriptExecutionContext)) { pars[i] = context; } else if (Parameters[i].ParameterType == typeof(CallbackArguments)) { pars[i] = args.SkipMethodCall(); } // else, ignore out params else if (Parameters[i].IsOut) { pars[i] = null; } else if (i == Parameters.Length - 1 && VarArgsArrayType != null) { List <DynValue> extraArgs = new List <DynValue>(); while (true) { DynValue arg = args.RawGet(j, false); j += 1; if (arg != null) { extraArgs.Add(arg); } else { break; } } // here we have to worry we already have an array.. damn. We only support this for userdata. // remains to be analyzed what's the correct behavior here. For example, let's take a params object[].. // given a single table parameter, should it use it as an array or as an object itself ? if (extraArgs.Count == 1) { DynValue arg = extraArgs[0]; if (arg.Type == DataType.UserData && arg.UserData.Object != null) { if (VarArgsArrayType.IsAssignableFrom(arg.UserData.Object.GetType())) { pars[i] = arg.UserData.Object; continue; } } } // ok let's create an array, and loop Array vararg = CreateVarArgArray(extraArgs.Count); for (int ii = 0; ii < extraArgs.Count; ii++) { vararg.SetValue(ScriptToClrConversions.DynValueToObjectOfType(extraArgs[ii], VarArgsElementType, null, false), ii); } pars[i] = vararg; } // else, convert it else { var arg = args.RawGet(j, false) ?? DynValue.Void; pars[i] = ScriptToClrConversions.DynValueToObjectOfType(arg, Parameters[i].ParameterType, Parameters[i].DefaultValue, !Parameters[i].DefaultValue.IsDbNull()); j += 1; } } object retv = null; if (m_OptimizedFunc != null) { retv = m_OptimizedFunc(obj, pars); } else if (m_OptimizedAction != null) { m_OptimizedAction(obj, pars); retv = DynValue.Void; } else if (m_IsAction) { MethodInfo.Invoke(obj, pars); retv = DynValue.Void; } else { if (IsConstructor) { retv = ((ConstructorInfo)MethodInfo).Invoke(pars); } else { retv = MethodInfo.Invoke(obj, pars); } } if (outParams == null) { return(ClrToScriptConversions.ObjectToDynValue(script, retv)); } else { DynValue[] rets = new DynValue[outParams.Count + 1]; rets[0] = ClrToScriptConversions.ObjectToDynValue(script, retv); for (int i = 0; i < outParams.Count; i++) { rets[i + 1] = ClrToScriptConversions.ObjectToDynValue(script, pars[outParams[i]]); } return(DynValue.NewTuple(rets)); } }
/// <summary> /// Creates a new DynValue from a CLR object /// </summary> /// <param name="script">The script.</param> /// <param name="obj">The object.</param> public static DynValue FromObject(Script script, object obj) { return(ClrToScriptConversions.ObjectToDynValue(script, obj)); }