Пример #1
0
        private ReflectedMethodInfo CreateMethodInfo(ScriptEngine.Machine.MethodInfo methInfo)
        {
            var reflectedMethod = new ReflectedMethodInfo(methInfo.Name);

            reflectedMethod.IsFunction = methInfo.IsFunction;
            for (int i = 0; i < methInfo.Params.Length; i++)
            {
                var currentParam   = methInfo.Params[i];
                var reflectedParam = new ReflectedParamInfo("param" + i.ToString(), currentParam.IsByValue);
                reflectedParam.SetOwner(reflectedMethod);
                reflectedParam.SetPosition(i);
                reflectedMethod.Parameters.Add(reflectedParam);
            }

            return(reflectedMethod);
        }
Пример #2
0
            private static MethodInfo CreateMetadata(System.Reflection.MethodInfo target, ContextMethodAttribute binding)
            {
                var parameters = target.GetParameters();
                var isFunc     = target.ReturnType != typeof(void);
                var argNum     = parameters.Length;

                var paramDefs = new ParameterDefinition[argNum];

                for (int i = 0; i < argNum; i++)
                {
                    var pd = new ParameterDefinition();
                    if (parameters[i].GetCustomAttributes(typeof(ByRefAttribute), false).Length != 0)
                    {
                        if (parameters[i].ParameterType != typeof(IVariable))
                        {
                            throw new InvalidOperationException("Attribute ByRef can be applied only on IVariable parameters");
                        }
                        pd.IsByValue = false;
                    }
                    else
                    {
                        pd.IsByValue = true;
                    }

                    if (parameters[i].IsOptional)
                    {
                        pd.HasDefaultValue   = true;
                        pd.DefaultValueIndex = ParameterDefinition.UNDEFINED_VALUE_INDEX;
                    }

                    paramDefs[i] = pd;
                }

                var scriptMethInfo = new ScriptEngine.Machine.MethodInfo();

                scriptMethInfo.IsFunction           = isFunc;
                scriptMethInfo.IsExport             = true;
                scriptMethInfo.IsDeprecated         = binding.IsDeprecated;
                scriptMethInfo.ThrowOnUseDeprecated = binding.ThrowOnUse;
                scriptMethInfo.Name  = binding.GetName();
                scriptMethInfo.Alias = binding.GetAlias(target.Name);

                scriptMethInfo.Params = paramDefs;

                return(scriptMethInfo);
            }
Пример #3
0
        private void MapType(Type type)
        {
            var methods = type.GetMethods()
                          .Where(x => x.GetCustomAttributes(typeof(ContextMethodAttribute), false).Any())
                          .Select(x => new {
                Method  = x,
                Binding = (ContextMethodAttribute)x.GetCustomAttributes(typeof(ContextMethodAttribute), false)[0]
            });

            foreach (var item in methods)
            {
                const int MAX_ARG_SUPPORTED = 8;
                var       parameters        = item.Method.GetParameters();
                var       paramTypes        = parameters.Select(x => x.ParameterType).ToList();
                var       isFunc            = item.Method.ReturnType != typeof(void);
                if (isFunc)
                {
                    paramTypes.Add(item.Method.ReturnType);
                }
                var argNum = paramTypes.Count;

                if (argNum <= MAX_ARG_SUPPORTED)
                {
                    var action  = ResolveGeneric(argNum, paramTypes.ToArray(), isFunc);
                    var methPtr = (ContextCallableDelegate <TInstance>)action.Invoke(this, new object[] { item.Method });

                    if (isFunc)
                    {
                        argNum--;
                    }

                    var paramDefs = new ParameterDefinition[argNum];
                    for (int i = 0; i < argNum; i++)
                    {
                        var pd = new ParameterDefinition();
                        if (parameters[i].GetCustomAttributes(typeof(ByRefAttribute), false).Length != 0)
                        {
                            if (paramTypes[i] != typeof(IVariable))
                            {
                                throw new InvalidOperationException("Attribute ByRef can be applied only on IVariable parameters");
                            }
                            pd.IsByValue = false;
                        }
                        else
                        {
                            pd.IsByValue = true;
                        }

                        if (parameters[i].IsOptional)
                        {
                            pd.HasDefaultValue   = true;
                            pd.DefaultValueIndex = ParameterDefinition.UNDEFINED_VALUE_INDEX;
                        }

                        paramDefs[i] = pd;
                    }

                    var scriptMethInfo = new ScriptEngine.Machine.MethodInfo();
                    scriptMethInfo.IsFunction = isFunc;
                    scriptMethInfo.Name       = item.Binding.GetName().ToLower();
                    scriptMethInfo.Alias      = item.Binding.GetAlias().ToLower();
                    scriptMethInfo.Params     = paramDefs;

                    _methodPtrs.Add(new InternalMethInfo()
                    {
                        method     = methPtr,
                        methodInfo = scriptMethInfo
                    });
                }
                else
                {
                    throw new NotSupportedException(string.Format("Only {0} parameters supported", MAX_ARG_SUPPORTED));
                }
            }
        }