protected override EvaluateResponse HandleEvaluateRequest(EvaluateArguments arguments)
{
try
{
var tree = _values.GetTree(arguments.Expression);
if (tree == null)
{
try
{
var value = Engine.Instance.Execute(arguments.Expression, ValueTree.Scope);
return(new EvaluateResponse(Engine.Instance.GetStr(value), 0));
}
catch
{
return(new EvaluateResponse("解析失败!", 0));
}
}
else if (tree.Value == null)
{
return(new EvaluateResponse(tree.Name, 0));
}
else
{
return(new EvaluateResponse(tree.Value.Description, tree.Id)
{
Type = tree.Value.TypeName
});
}
}
catch
{
return(new EvaluateResponse("解析失败!", 0));
}
}
protected override EvaluateResponse HandleEvaluateRequest(EvaluateArguments arguments)
{
var expression = arguments.Expression;
var symbolAddress = DebugMap?.GetSymbolAddress(expression.Trim());
if (symbolAddress.HasValue)
{
expression = $"[{symbolAddress.Value}]";
}
var result = Controller.Evaluate(expression);
if (result != null)
{
return(new EvaluateResponse()
{
Result = result
});
}
else
{
return(new EvaluateResponse()
{
Result = "<unknown symbol>",
PresentationHint = new VariablePresentationHint()
{
Attributes = VariablePresentationHint.AttributesValue.FailedEvaluation
}
});
}
}
internal EvaluateResponse HandleEvaluateRequest(EvaluateArguments args)
{
if (!args.FrameId.HasValue)
{
throw new ProtocolException("Evaluation without a frame id is not supported!");
}
SampleStackFrame frame = this.GetStackFrame(args.FrameId.Value);
if (frame == null)
{
throw new ProtocolException(Invariant($"Invalid frame id '{args.FrameId.Value}'!"));
}
return(frame.HandleEvaluateRequest(args));
}
protected override EvaluateResponse HandleEvaluateRequest(EvaluateArguments arguments)
{
try
{
if (session == null)
{
throw new InvalidOperationException();
}
return(session.Evaluate(arguments));
}
catch (Exception)
{
return(FailedEvaluation);
}
}
protected override EvaluateResponse HandleEvaluateRequest(EvaluateArguments arguments)
{
if (this.directiveProcessor.IsDirective(arguments.Expression))
{
string value = null;
int variablesReference = 0;
StringBuilder outputBuilder = new StringBuilder();
this.directiveProcessor.ProcessDirective(arguments.Expression, outputBuilder);
value = outputBuilder.ToString();
return(new EvaluateResponse(result: value, variablesReference: variablesReference));
}
return(this.ThreadManager.HandleEvaluateRequest(arguments));
}
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 EvaluateResponse Evaluate(EvaluateArguments args)
{
if ((engine.State & HALT_OR_FAULT) != 0)
{
return(DebugAdapter.FailedEvaluation);
}
var(typeHint, index, variableName) = Helpers.ParseEvalExpression(args.Expression);
if (variableName.StartsWith("$storage"))
{
return(engine.EvaluateStorageExpression(this, args));
}
Variable?GetVariable(StackItem item, Parameter local)
{
if (index.HasValue)
{
if (item is Neo.VM.Types.Array neoArray &&
index.Value < neoArray.Count)
{
return(neoArray[index.Value].GetVariable(this, local.Name + $"[{index.Value}]", typeHint));
}
}
else
{
return(item.GetVariable(this, local.Name, typeHint ?? local.Type));
}
return(null);
}
for (var stackIndex = 0; stackIndex < engine.InvocationStack.Count; stackIndex++)
{
var context = engine.InvocationStack.Peek(stackIndex);
if (context.AltStack.Count <= 0)
{
continue;
}
var method = Contract.GetMethod(context);
if (method == null)
{
continue;
}
var locals = method.Locals.ToArray();
var variables = (Neo.VM.Types.Array)context.AltStack.Peek(0);
for (int varIndex = 0; varIndex < Math.Min(variables.Count, locals.Length); varIndex++)
{
var local = locals[varIndex];
if (local.Name == variableName)
{
var variable = GetVariable(variables[varIndex], local);
if (variable != null)
{
return(new EvaluateResponse()
{
Result = variable.Value,
VariablesReference = variable.VariablesReference,
Type = variable.Type
});
}
}
}
}
return(DebugAdapter.FailedEvaluation);
}
public static EvaluateResponse EvaluateStorageExpression(this DebugExecutionEngine @this, IVariableContainerSession session, byte[] scriptHash, EvaluateArguments args) => @this.EvaluateStorageExpression(session, new UInt160(scriptHash), args);
public object Evaluate(EvaluateArguments args)
{
return Process (new DebuggerRequest () { Arguments = args, Command = "evaluate" }).Body;
}
internal EvaluateResponse HandleEvaluateRequest(EvaluateArguments arguments)
{
return(this.Evaluate(arguments.Expression, null, arguments.Format));
}
