public object HandleFunction(string FuncName, List <object> pparameters) { Debug.Print("HandleFunction:" + FuncName + "parameters:" + pparameters); //convert any Array's within tthis pparameters list into a List... List <object> parameters = (from ix in pparameters select((ix.GetType().IsArray)?((Object[])ix).ToList():ix)).ToList(); if (ArrayAwareFunctions.IndexOf(FuncName, StringComparison.OrdinalIgnoreCase) == -1 && parameters.Any((w) => w is List <Object>)) { List <Object> parms = parameters; List <Object> firstlist = null; int firstarrayindex = 0; //iterate through the parameters, saving a reference to the first (and ONLY the first) array argument. //we only do the first, because the intention is that the function call will recurse on this method and thus //have the same logic, so if there are further array arguments, they will be processed in the same manner (since they will //eventually be the "first" array in the list of parameters) for (int i = 0; i < parms.Count; i++) { if (firstlist == null && parms[i] is List <Object> ) { firstlist = ((List <Object>)parms[i]); firstarrayindex = i; } } //Now, using the parms array, create a new list of parameters for each element in that array. //iterate through each value in firstarray. Object[] Buildreturn = new object[firstlist.Count]; int a = 0; foreach (Object loopparameter in firstlist) { //create a new array... List <Object> useparameters = parms; //set the proper index to be the current scalar... useparameters[firstarrayindex] = loopparameter; //call the function. Buildreturn[a] = HandleFunction(FuncName, useparameters); a++; } return(Buildreturn); } double castdouble; switch (FuncName.ToLower()) { case "sin": return(Math.Sin((double)Convert.ChangeType(parameters[0], TypeCode.Double))); case "cos": return(Math.Cos((double)Convert.ChangeType(parameters[0], TypeCode.Double))); case "tan": return(Math.Tan((double)Convert.ChangeType(parameters[0], TypeCode.Double))); case "sqr": return(Math.Sqrt((double)Convert.ChangeType(parameters[0], TypeCode.Double))); case "log": return(Math.Log((double)Convert.ChangeType(parameters[0], TypeCode.Double))); case "exp": return(Math.Exp((double)Convert.ChangeType(parameters[0], TypeCode.Double))); case "round": return(Math.Round( (double)Convert.ChangeType(parameters[0], TypeCode.Double), (int)(Convert.ChangeType(parameters[1], TypeCode.Int32)))); case "array": return(parameters); case "range": //start,end,step if (parameters.Count < 2) { throw new CParser.ParserSyntaxError(0, "Insufficient arguments to Range function"); } //type conversion to doubles... double startval = (double)Convert.ChangeType(parameters[0], TypeCode.Double); double endval = (double)Convert.ChangeType(parameters[1], TypeCode.Double); double stepval = parameters.Count > 2?(double)Convert.ChangeType(parameters[2], TypeCode.Double):1; return(Range(endval, startval, stepval)); case "store": CParser parserobject = GetParserObject(); //store(variablename,variablevalue) //Variable founditem = parserobject.Variables.Find((w)=>w.Name==parameters[0].ToString()); Variable founditem = parserobject.Variables[parameters[0].ToString()]; if (founditem != null) { parserobject.Variables.Remove(founditem); } parserobject.Variables.Add((String)parameters[0], parameters[1]); return(parameters[1]); case "seq": //seq(var,initexpr,incrementexpression,terminateexpression) List <Object> buildresult = new List <object>(); CParser parserobj = GetParserObject(); Variable foundvar = parserobj.Variables[parameters[0].ToString()]; if (foundvar == null) { foundvar = parserobj.Variables.Add(parameters[0].ToString(), null); } //get the expressions. String initexpression = (String)parameters[1]; String incrementExpression = (String)parameters[2]; String terminateExpression = (String)parameters[3]; CParser Initializer = GetParserObject(); Initializer.Expression = initexpression; Initializer.Execute(); CParser incrementor = GetParserObject(); incrementor.Expression = incrementExpression; CParser terminator = GetParserObject(); terminator.Expression = terminateExpression; while (!((bool)terminator.Execute())) { buildresult.Add(foundvar.Value); incrementor.Execute(); } return(buildresult); break; case "createobject": if (parameters.Count() == 0) { throw new ArgumentException("CreateObject requires at least 1 argument"); } object returnobject = CParser.CreateCOMObject((string)parameters[0]); if (returnobject == null) { //returnobject=Activator.CreateInstance(AssemblyName,typeName,Binder,args[],Cultureinfo culture) String lAsmName = (String)parameters[0]; String mTypename = (String)parameters[1]; object[] constructorargs = parameters.GetRange(2, parameters.Count() - 2).ToArray(); ObjectHandle objhandle = Activator.CreateInstance(lAsmName, mTypename, true, BindingFlags.CreateInstance, null, constructorargs, CultureInfo.CurrentCulture, null, null); return(objhandle.Unwrap()); } return(null); default: return(null); } }