public object HandleAssignmentOperator(CParser withparser, string Operator, string LValue, CParser RValue)
{
//Three steps:
//if the Operator is not the standard Assignment Operator, =...
//first, we need to figure out what the assign the value to.
//for now, we either find or create a Variable.
Variable usevariable = withparser.Variables[LValue];
if (Operator == ":=")
{
usevariable.Value = RValue.Execute();
}
else
{
//it must be something like += or -=. Get the Binary operator...
String binop = Operator.Substring(0, Operator.Length - 1);
Object OperandA = usevariable.Value;
Object OperandB = RValue.Execute();
//perform the binary operation.
Object result = withparser.HandleOperation(binop, OperandA, OperandB);
//store it back into the variable.
usevariable.Value = result;
}
return(usevariable.Value);
return(null);
}
//expression should refer to p[0], p[1], etc to access the parameters passed to it.
/// <summary>
/// invokes this function using the given set of parameters.
/// </summary>
/// <param name="parameters">the parameters to pass too the functions expression.</param>
/// <returns>the executed result from the function, or null of an error occurs.</returns>
public Object Invoke(Object[] parameters)
{
//first, assign the parameters variable....
//mParser.Variables.Find((w)=>w.Key.Equals("P")).Value = parameters;
//mParser.Variables.RemoveAll((w) => w.Name == "P");
//mParser.Variables.Add("P",parameters);
mParser.Variables["P"].Value = parameters;
return(mParser.Execute());
}
public void TestOperators()
{
CParser testparser = new CParser();
String[] ExpressionsUse = { "12+5", "{1,2,3}", "14-12+5*Sqr(64)" };
Object[] Expectedresults = { (object)17, (object)(new object[] { 1f, 2f, 3f }).ToList(), 14 - 12 + 5 * 8 };
int failcount = 0;
for (int i = 0; i < ExpressionsUse.Length; i++)
{
Object tempobject = testparser.Execute(ExpressionsUse[i]);
if (Convert.ChangeType(tempobject, Expectedresults[i].GetType()).Equals(Expectedresults[i]) ||
(testparser.ResultToString(tempobject).Equals(testparser.ResultToString(Expectedresults[i])))
)
//if (tempobject == Expectedresults[i])
{
Debug.Print(ExpressionsUse[i] + " success. Result was " + testparser.ResultToString(tempobject));
}
else
{
Debug.Print(ExpressionsUse[i] + " failed. Result was " + testparser.ResultToString(tempobject) + "Expected result was " + testparser.ResultToString(Expectedresults[i]));
failcount++;
}
}
if (failcount > 0)
{
Assert.Fail(failcount.ToString() + "/" + ExpressionsUse.Length + " tests failed.");
}
}
public void TestOperators()
{
CParser testparser = new CParser();
String[] ExpressionsUse = {"12+5","{1,2,3}","14-12+5*Sqr(64)"};
Object[] Expectedresults = {(object)17,(object)(new object[] {1f,2f,3f}).ToList(),14-12+5*8};
int failcount=0;
for (int i = 0; i < ExpressionsUse.Length; i++)
{
Object tempobject = testparser.Execute(ExpressionsUse[i]);
if (Convert.ChangeType(tempobject, Expectedresults[i].GetType()).Equals( Expectedresults[i])
|| (testparser.ResultToString(tempobject).Equals(testparser.ResultToString(Expectedresults[i])))
)
//if (tempobject == Expectedresults[i])
{
Debug.Print(ExpressionsUse[i] + " success. Result was " + testparser.ResultToString(tempobject));
}
else
{
Debug.Print(ExpressionsUse[i] + " failed. Result was " + testparser.ResultToString(tempobject) + "Expected result was " + testparser.ResultToString(Expectedresults[i]));
failcount++;
}
}
if (failcount > 0)
Assert.Fail(failcount.ToString() + "/" + ExpressionsUse.Length + " tests failed.");
}
private void btnexec_Click(object sender, EventArgs e)
{
mParser.Expression = txtinput.Text;
Object resultacquired = null;
try
{
resultacquired = mParser.Execute();
String stringresult = mParser.ResultToString(resultacquired);
txtresults.Text += System.Environment.NewLine + stringresult;
}
catch (Exception err)
{
txtresults.Text += System.Environment.NewLine;
txtresults.Select(txtresults.Text.Length, 0);
txtresults.SelectedText = "Exception:" + err.Message + " Source: " + err.Source + System.Environment.NewLine +
"Stack trace:" + System.Environment.NewLine + err.StackTrace + System.Environment.NewLine;
txtresults.SelectionFont = new Font(txtresults.SelectionFont, FontStyle.Bold);
txtresults.Select(txtresults.Text.Length, 0);
txtresults.ScrollToCaret();
}
}
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);
}
}