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);
}
}
