public EvaluatorResult Evaluate(IInterpreterContext context, string expression)
{
var resolver = new FilepathResolver();
string expr = resolver.ResolvePath(context, expression);
switch (LogType)
{
case "Log":
System.Console.Out.WriteLine(expr);
break;
case "Info":
logger.Info(expr);
break;
case "Debug":
logger.Debug(expr);
break;
case "Error":
logger.Error(expr);
break;
case "Trace":
logger.Trace(expr);
break;
default:
break;
}
return(new EvaluatorResult(true, string.Empty));
}
public EvaluatorResult Evaluate(IInterpreterContext context, string expression)
{
var resolver = new FilepathResolver();
string expr = resolver.ResolvePath(context, expression);
context.Emitter.Open(expr);
return(new EvaluatorResult(true, string.Empty));
}
public EvaluatorResult Evaluate(IInterpreterContext context, string expression)
{
var loop = context.EvaluateLoop(expression);
bool result = loop.HasMore || loop.CurrentModel != null;
return(new EvaluatorResult(result, string.Empty));
}
/// <summary>
/// Sets an interpreter context to be use un variables resolution.
/// </summary>
/// <param name="name">The name of the context..</param>
/// <param name="interpreterContext">An object that implements Hef.Math.IInterpreterContext. Null to re;ove context.</param>
public void SetContext(string name, IInterpreterContext interpreterContext)
{
if (interpreterContext == null)
{
this.namedContext.Remove(name);
}
else
{
if (!this.namedContext.ContainsKey(name))
{
this.namedContext.Add(name, interpreterContext);
}
else
{
this.namedContext[name] = interpreterContext;
}
}
}
public EvaluatorResult Evaluate(IInterpreterContext context, string expression)
{
// check for references:
while (expression.Contains("["))
{
// evaluate the sub-expression into the current expression
expression = EvaluateReferences(context, expression);
}
string result = context.EvaluateProperty(expression);
// check for references in the result:
while (result.Contains("["))
{
// evaluate the sub-expression into the current expression
result = EvaluateReferences(context, result);
}
return(new EvaluatorResult(true, result));
}
/// <summary>
/// example:
/// xyz[abc][def[ghi]]
/// 1) xyz[abc][def[ghi]]
/// 2) abc][def[ghi]]
/// 3) def[ghi]]
/// 4) ghi]] --> refghi
/// </summary>
/// <param name="subExpr"></param>
/// <returns></returns>
private string EvaluateReferences(IInterpreterContext context, string subExpr)
{
var start = subExpr.IndexOf('[');
var end = subExpr.IndexOf(']');
if (subExpr.Substring(start + 1, end - start - 1).Contains("["))
{
// we have nested references, resolve this first
var refres = EvaluateReferences(context, subExpr.Substring(start + 1));
// add the evaluate sub-expression to the current prefix
subExpr = subExpr.Substring(0, start + 1) + refres;
// recalc the end position in the sub-expression of the end of the sub-expression
end = subExpr.IndexOf(']');
}
// evaluate the sub-expression
var result = Evaluate(context, subExpr.Substring(start + 1, end - start - 1));
// insert the result in the current sub-expression
subExpr = subExpr.Substring(0, start) + result.Value + subExpr.Substring(end + 1);
return(subExpr);
}
public string ResolvePath(IInterpreterContext context, string expression)
{
string path = "";
// split in string and expressions
int start = 0, xprIndex, xprEnd;
while (start < expression.Length)
{
string walk = expression.Substring(start);
xprIndex = walk.IndexOf("=<");
xprEnd = walk.IndexOf(">");
if (xprIndex >= 0 && xprEnd > xprIndex)
{
if (xprIndex != 0)
{
// before the expression
list.Add(walk.Substring(0, xprIndex));
}
// expression itself
xprIndex += 2;
// evaluate expression
var result = context.EvaluateProperty(walk.Substring(xprIndex, xprEnd - xprIndex));
list.Add(result);
start += xprEnd + 1;
}
else
{
list.Add(walk);
break;
}
}
// reconstruct result string
path = list.Aggregate(path, (c, s) => c += s);
return(path);
}
public EvaluatorResult Evaluate(IInterpreterContext context, string expression)
{
string LeftValue;
try
{
if (checkForExistence)
{
var res = context.PropertyExists(leftSide);
// just check existence, nothing else, or it does not exist
if (res == false || NoRightSide)
{
if (IsNegate)
{
res = !res;
}
return(new EvaluatorResult(res, string.Empty));
}
}
// existence of property is assumed (it is either checked or no "?" was present
if (evaluator is Evaluator.ExpressionEvaluator)
{
LeftValue = context.EvaluateProperty(leftSide);
}
else
{
var evalRes = evaluator.Evaluate(context, leftSide);
if (evalRes.Result == EvaluationResultValues.True)
{
LeftValue = evalRes.Value;
}
else
{
LeftValue = "error";
}
}
}
catch (Exception ex)
{
return(new EvaluatorResult(ex));
}
LeftValue = LeftValue.ToLower();
bool retVal;
if (CompareEqual)
{
retVal = LeftValue == rightSide;
}
else
{
retVal = LeftValue != rightSide;
}
// leading "!" is valid for the complete if-clause
if (IsNegate)
{
retVal = !retVal;
}
return(new EvaluatorResult(retVal, string.Empty));
}
public EvaluatorResult Evaluate(IInterpreterContext context, string expression)
{
return(new EvaluatorResult(true, (context.EvaluateLoop(expression).Index + 1).ToString()));
}
public EvaluatorResult Evaluate(IInterpreterContext context, string expression)
{
context.EnterLoop(expression);
return(new EvaluatorResult(true, string.Empty));
}
public EvaluatorResult Evaluate(IInterpreterContext context, string expression)
{
return(new EvaluatorResult(true, expression));
}
public EvaluatorResult Evaluate(IInterpreterContext context, string expression)
{
return(new EvaluatorResult(true, DateTime.Now.ToString("dd/MMM/yyyy HH:mm:ss")));
}
