Exemplo n.º 1
0
        /// <summary>
        /// Decorate a native C# function with QsFunction
        /// </summary>
        /// <param name="methodInfo"></param>
        /// <param name="funcAttribute"></param>
        /// <returns></returns>
        public QsFunction GetQsFunctionFromTypeMethod(MethodInfo methodInfo, QsFunctionAttribute funcAttribute)
        {
            string qsNamespace = this._NamespaceType.Name;

            string qsFuncName = funcAttribute == null ? methodInfo.Name : funcAttribute.FunctionName;

            var miParameters     = methodInfo.GetParameters();
            int qsFuncParamCount = miParameters.Length;


            QsFunction QsModFunc = new QsFunction("[" + qsNamespace + "." + qsFuncName + "]", true);

            QsModFunc.FunctionNamespace = qsNamespace;
            QsModFunc.FunctionName      = qsFuncName;

            List <QsParamInfo> prms = new List <QsParamInfo>(miParameters.Length);

            foreach (var miParam in miParameters)
            {
                QsParamInfo prm = new QsParamInfo();

                //parameter name
                prm.Name = miParam.Name;

                var pis = miParam.GetCustomAttributes(typeof(QsParamInfoAttribute), true);

                if (pis.Length > 0)
                {
                    prm.Type = ((QsParamInfoAttribute)pis[0]).ParameterType;
                }
                else
                {
                    prm.Type = QsParamType.Value;
                }

                prms.Add(prm);
            }

            QsModFunc.Parameters           = prms.ToArray();
            QsModFunc.FunctionDeclaration += "(";
            StringBuilder sb = new StringBuilder();

            foreach (var p in prms)
            {
                sb.Append(", " + p.Name);
            }
            if (sb.Length > 0)
            {
                QsModFunc.FunctionDeclaration += sb.ToString().TrimStart(',', ' ');
            }
            QsModFunc.FunctionDeclaration += ")";



            QsModFunc.InternalFunctionDelegate = FormNativeFunctionDelegate(methodInfo);
            return(QsModFunc);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Gets the members of the QsNamespace or (static class ) that hold the hard coded functions and properties.
        /// </summary>
        /// <param name="namespaceType"></param>
        /// <returns></returns>
        private Dictionary <string, object> GetQsNamespaceMethods()
        {
            // The namespace is a static class with public visibility to its static members.
            var methods = _NamespaceType.GetMethods(
                BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public
                /*| BindingFlags.InvokeMethod */
                );

            Dictionary <string, object> CodedMembers =
                new Dictionary <string, object>(System.StringComparer.OrdinalIgnoreCase);

            /*
             * var FilteredMethods = from m in methods
             *                    where
             *                    m.IsSpecialName == false
             *
             *                    && m.ReturnType.IsArray == false &&
             *                    (m.ReturnType.BaseType == typeof(QsValue) || m.ReturnType == typeof(QsValue) ||
             *                    m.ReturnType == typeof(string) || m.ReturnType.IsValueType == true)
             *
             *                    select m;
             */
            var FilteredMethods = from m in methods
                                  where
                                  m.IsSpecialName == false
                                  select m;

            foreach (var member in FilteredMethods)
            {
                var method = ((MethodInfo)member);
                if (!method.IsSpecialName) //because properies getters are methods also :S
                {
                    ParameterInfo[] mps = method.GetParameters();


                    int paramCount = mps.Length;


                    var fAttributes = method.GetCustomAttributes(typeof(QsFunctionAttribute), false);

                    QsFunctionAttribute funcAttribute = null;
                    string method_name    = string.Empty;
                    string methodTrueName = string.Empty;

                    if (fAttributes.Length > 0)
                    {
                        funcAttribute = (QsFunctionAttribute)fAttributes[0];

                        // if the attribute were found treat the function as namedargument function that is not default function.
                        method_name = funcAttribute.FunctionName;

                        if (funcAttribute.DefaultScopeFunction == false)
                        {
                            // alter the name so it includes the parameters also
                            string[] ptext = (from p in mps select p.Name).ToArray();
                            methodTrueName = QsFunction.FormFunctionSymbolicName(method_name, ptext);
                        }
                        else
                        {
                            // don't use special parameter symbolic naming.
                            methodTrueName = QsFunction.FormFunctionSymbolicName(method_name, paramCount);
                        }

                        CodedMembers.Add(methodTrueName, GetQsFunctionFromTypeMethod(method, funcAttribute));
                    }
                    else
                    {
                        method_name    = method.Name;
                        methodTrueName = QsFunction.FormFunctionSymbolicName(method_name, paramCount);

                        CodedMembers.Add(methodTrueName, GetQsFunctionFromTypeMethod(method, null));
                    }
                }
            }

            return(CodedMembers);
        }