Ejemplo n.º 1
0
 public static JavaScriptValue FieldSetter(JavaScriptValue callee,
                                           [MarshalAs(UnmanagedType.U1)] bool isConstructCall,
                                           [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] JavaScriptValue[] arguments,
                                           ushort argumentCount,
                                           IntPtr callbackData)
 {
     try
     {
         var that = (FieldProxy)GCHandle.FromIntPtr(callbackData).Target;
         if (that.setdg == null)
         {
             that.setdg = (obj, val) =>
             {
                 var valv = FunctionWrapper.Conv(val, that.fi.FieldType);
                 if (that.fi.IsStatic)
                 {
                     that.fi.SetValue(null, valv);
                 }
                 else
                 {
                     var objv = FunctionWrapper.Conv(obj, that.fi.DeclaringType);
                     that.fi.SetValue(objv, valv);
                 }
             };
         }
         that.setdg(arguments[0], arguments[1]);
         return(arguments[1]);
     }
     catch (Exception e)
     {
         return(ExceptionUtil.SetJSException(e));
     }
 }
Ejemplo n.º 2
0
 public static JavaScriptValue PropertySetter(JavaScriptValue callee,
                                              [MarshalAs(UnmanagedType.U1)] bool isConstructCall,
                                              [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] JavaScriptValue[] arguments,
                                              ushort argumentCount,
                                              IntPtr callbackData)
 {
     try
     {
         var that = (PropertyProxy)GCHandle.FromIntPtr(callbackData).Target;
         if (that.setdg == null)
         {
             var settermethod = that.pi.GetSetMethod();
             that.setdg = (obj, val) =>
             {
                 var valv = FunctionWrapper.Conv(val, that.pi.PropertyType);
                 if (settermethod.IsStatic)
                 {
                     settermethod.Invoke(null, new object[] { valv });
                 }
                 else
                 {
                     var objv = FunctionWrapper.Conv(obj, that.pi.DeclaringType);
                     settermethod.Invoke(objv, new object[] { valv });
                 }
             };
         }
         that.setdg(arguments[0], arguments[1]);
         return(arguments[1]);
     }
     catch (Exception e)
     {
         return(ExceptionUtil.SetJSException(e));
     }
 }
Ejemplo n.º 3
0
            public OverloadEntry(MethodBase mi)
            {
                IEnumerable <ParameterData> ie;

                if (mi.IsStatic || mi is ConstructorInfo)
                {
                    ie = new ParameterData[] { new ParameterData()
                                               {
                                                   name = "(static this)"
                                               } };
                }
                else
                {
                    ie = new ParameterData[] {
                        new ParameterData {
                            name          = "this",
                            parameterType = mi.DeclaringType
                        }
                    };
                }
                ie = ie.Concat(mi.GetParameters().Select(e =>
                {
                    var d           = new ParameterData();
                    d.name          = e.Name;
                    d.parameterType = e.ParameterType;
                    d.isOut         = e.IsOut;
                    d.isParams      = e.IsDefined(typeof(ParamArrayAttribute), false);
                    return(d);
                }));
                ps = ie.ToArray();

                cachedFunction = null;
                entityWrapper  = null;
                cachedData     = default(GCHandle);
                if (mi is ConstructorInfo)
                {
                    entityWrapper = new ConstructorWrapper((ConstructorInfo)mi);
                }
                else if (mi is MethodInfo)
                {
                    if (mi.IsStatic)
                    {
                        entityWrapper = new StaticMethodWrapper((MethodInfo)mi);
                    }
                    else
                    {
                        entityWrapper = new InstanceMethodWrapper((MethodInfo)mi);
                    }
                }
            }