public void GetAndEvaluateEvalExpression()
{
EvalExpression expression = EvalExpression.Instance;
Assert.IsNotNull(expression);
Machine machine = new Machine();
IList list = new ArrayList();
list.Add(1);
list.Add(2);
machine.Push(list);
machine.Push("dup add_int add_int");
expression.Evaluate(machine);
Assert.AreEqual(1, machine.StackCount);
Assert.IsInstanceOfType(machine.Top(), typeof(IList));
IList result = (IList)machine.Pop();
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Count);
Assert.AreEqual(5, result[0]);
}
internal EvalExpression GenEvalExpression(IScope scope)
{
scope.Require(GlobalFunction.TRYC);
var ee = new EvalExpression();
ee.Code = _rand.GenEvalString(_options.EvalStringLength.RandomValue(_rand));
return(ee);
}
public int ParseText(string pszCode, enum_PARSEFLAGS dwFlags, uint nRadix, out IDebugExpression2 ppExpr,
out string pbstrError, out uint pichError)
{
pbstrError = "";
pichError = 0;
ppExpr = null;
Parser parser = new Parser(pszCode);
EvalExpression exp = null;
try
{
exp = parser.Parse();
}
catch (Exception ex)
{
pbstrError = ex.Message;
pichError = (uint)pbstrError.Length;
return(Constants.S_FALSE);
}
ppExpr = new AD7Expression(this, exp, pszCode);
return(Constants.S_OK);
/*string[] names = pszCode.Split('.');
* ILProperty root = null;
* if(!propertyMapping.TryGetValue(names[0], out root))
* {
* if (!propertyMapping.TryGetValue("this", out root))
* {
* pbstrError = "Unsupported Expression";
* pichError = (uint)pbstrError.Length;
* return Constants.S_FALSE;
* }
* }
*
* if (names.Length < 2)
* {
* ppExpr = new AD7Expression(root);
* return Constants.S_OK;
* }
* else
* {
* ppExpr = new AD7Expression(Engine, Thread, root, names);
* return Constants.S_OK;
* }*/
/*string lookup = pszCode;
*
*
* LocalVariable result = ThreadContext.GetVisibleVariableByName(lookup);
* if (result != null)
* {
* ppExpr = new AD7Expression(new MonoProperty(ThreadContext, result));
* return VSConstants.S_OK;
* }
*/
}
/// <summary>
/// Compile a function string ("sin(t, C)") into a Func<double, double>, connect it with the sample and store it.
/// </summary>
/// <param name="text">A string that represents a function that can be used to generate a waveform.</param>
private void CompileFunction(string text)
{
IExpressionEvaluator eval = new ExpressionEvaluator(ExpressionLanguage.CSharp);
var context = new EvalContext {
S = this
};
EvalExpression <double, EvalContext> expression = eval.GetDelegate <double, EvalContext>(text);
_compiledfunction = GetMethod(context, expression);
}
/// <summary>
/// Since an EvalExpression can't take any parameters but takes all its information from its evaluation context object
/// we'll need a wrapper to create a convenient Func<double, double> to use for the calculations.
/// </summary>
/// <param name="context"></param>
/// <param name="expr"></param>
/// <returns></returns>
private static Func <double, double> GetMethod(EvalContext context, EvalExpression <double, EvalContext> expr)
{
Func <double, double> ret = delegate(double t)
{
context.t = t;
return(expr(context));
};
return(ret);
}
public void TestExpression()
{
var expr = "(Age != null) && (Id > 0)";
var context = new EvalExpression();
var result = context.Create <P>(expr);
var flag1 = result.Func(new P {
Id = 2, Age = null
});
var flag2 = result.Func(new P {
Id = 2, Age = 2
});
}
/// <summary>
/// Compiles an expression and returns a delegate to the compiled code.
/// </summary>
/// <typeparam name="R">The return type of the expression</typeparam>
/// <typeparam name="C">The type of the function class</typeparam>
/// <param name="expression">Expression to evaluate</param>
/// <returns>EvalExpression<R, C> - a delegate that calls the compiled expression</returns>
internal EvalExpression <R, C> GetDelegate <R, C>(string expression)
{
EvalExpression <R, C> methodDelegate = null;
//get compiled method
var methodState = GetMethodState <R, C>(expression);
if (methodState != null)
{
//Get delegate for method state
methodDelegate = GetDelegate <R, C>(methodState);
}
return(methodDelegate);
}
/// <summary>
/// Compiles an expression and returns a delegate to the compiled code.
/// </summary>
/// <typeparam name="R">The return type of the expression</typeparam>
/// <typeparam name="C">The type of the function class</typeparam>
/// <param name="expression">Expression to evaluate</param>
/// <returns>EvalExpression<R, C> - a delegate that calls the compiled expression</returns>
public EvalExpression <R, C> GetDelegate <R, C>(string expression)
{
DynamicMethodState methodState;
EvalExpression <R, C> methodDelegate = null;
//get compiled method
methodState = GetMethodState <R, C>(expression);
if (methodState != null)
{
//Get delegate for method state
methodDelegate = GetDelegate <R, C>(methodState);
}
return(methodDelegate);
}
public IProperty Resolve(IStackFrame frame, EvalExpression exp, uint dwTimeout)
{
if (exp != null)
{
if (exp is NameExpression)
{
return(ResolveNameExpression(frame, (NameExpression)exp, dwTimeout));
}
if (exp is MemberAcessExpression)
{
return(ResolveMemberAccessExpression(frame, (MemberAcessExpression)exp, dwTimeout));
}
if (exp is IndexAccessExpression)
{
return(ResolveIndexAccessExpression(frame, (IndexAccessExpression)exp, dwTimeout));
}
}
return(null);
}
ILProperty Resolve(EvalExpression exp, uint dwTimeout)
{
if (exp != null)
{
if (exp is NameExpression)
{
return(ResolveNameExpression((NameExpression)exp, dwTimeout));
}
if (exp is MemberAcessExpression)
{
return(ResolveMemberAccessExpression((MemberAcessExpression)exp, dwTimeout));
}
if (exp is IndexAccessExpression)
{
return(ResolveIndexAccessExpression((IndexAccessExpression)exp, dwTimeout));
}
}
return(null);
}
private string ResolveIfNode <T>(IfNode node, T parameter)
{
if (node.Delegate == null)
{
lock (this)
{
var context = new EvalExpression();
var result = context.Create <T>(node.Test);
node.Delegate = result.Func;
}
}
var func = node.Delegate as Func <T, bool>;
if (func(parameter))
{
return(ResolveTextNode(new TextNode {
Value = node.Value
}));
}
return(string.Empty);
}
protected override EvaluateResponse HandleEvaluateRequest(EvaluateArguments arguments)
{
Parser parser = new Parser(arguments.Expression);
EvalExpression exp = null;
try
{
exp = parser.Parse();
}
catch (Exception ex)
{
throw new ProtocolException(ex.ToString());
}
VSCodeStackFrame frame;
foreach (var t in debugged.Threads)
{
var thread = t.Value as VSCodeThread;
frame = thread.FindFrame(arguments.FrameId.GetValueOrDefault());
if (frame != null)
{
var prop = debugged.Resolve(frame, exp, (uint)Math.Max(arguments.Timeout.GetValueOrDefault(), 5000)) as VSCodeVariable;
if (prop.Info.Expandable)
{
frame.RegisterVariable(prop);
}
return(new EvaluateResponse()
{
Result = prop.Info.Value,
Type = prop.Info.TypeName,
VariablesReference = prop.Info.Expandable ? prop.GetHashCode() : 0
});
}
}
throw new ProtocolException($"Evaluation failed:{arguments.Expression}");
}
public AD7Expression(AD7StackFrame frame, EvalExpression exp, string oriExp)
{
this.frame = frame;
this.exp = exp;
this.oriExp = oriExp;
}
public IActionResult Post([FromBody] EvalExpression expression) => Ok(new ExpressionWithResult
{
Expression = expression.Expression,
Result = evaluator.Evaluate(expression.Expression)
});
private static object Compute(EvalExpression exp, EntityModelBase modelBase)
{
return(null);
}
