public Variable(
string name,
string value,
long variablesReference,
string type = null,
VariablePresentationHint presentationHint = null,
string evaluateName = null,
long?namedVariables = null,
long?indexedVariables = null,
string memoryReference = null)
{
Name = name;
Value = value;
Type = type;
PresentationHint = presentationHint;
EvaluateName = evaluateName;
VariablesReference = variablesReference;
NamedVariables = namedVariables;
IndexedVariables = indexedVariables;
MemoryReference = memoryReference;
}
protected override Variable CreateProtocolObject()
{
ValueFormat format = this.Format;
VariablePresentationHint presentationHint = new VariablePresentationHint();
if (this.IsReadOnly)
{
presentationHint.Attributes = VariablePresentationHint.AttributesValue.ReadOnly;
}
else
{
presentationHint.Attributes = VariablePresentationHint.AttributesValue.None;
}
return(new Variable(
name: this.Name,
value: this.GetValue(format?.Hex ?? false),
type: this.Type,
variablesReference: (this.GetChildren() != null && this.GetChildren().Any()) ? this.Adapter.GetNextId() : 0,
evaluateName: this.GetEvaluateName(),
presentationHint: presentationHint));
}
protected ObjectValueFlags GetFlags(VariablePresentationHint hint)
{
var flags = ObjectValueFlags.None;
if (hint != null)
{
if (hint.Attributes.HasValue)
{
var attributes = hint.Attributes.Value;
if ((attributes & VariablePresentationHint.AttributesValue.FailedEvaluation) != 0)
{
return(ObjectValueFlags.Error);
}
if ((attributes & VariablePresentationHint.AttributesValue.Constant) != 0)
{
flags |= ObjectValueFlags.Literal;
}
if ((attributes & VariablePresentationHint.AttributesValue.ReadOnly) != 0)
{
flags |= ObjectValueFlags.ReadOnly;
}
if ((attributes & VariablePresentationHint.AttributesValue.Static) != 0)
{
flags |= ObjectValueFlags.ReadOnly;
}
if ((attributes & VariablePresentationHint.AttributesValue.CanHaveObjectId) != 0)
{
flags |= ObjectValueFlags.Primitive;
}
if ((attributes & VariablePresentationHint.AttributesValue.HasObjectId) != 0)
{
flags |= ObjectValueFlags.Object;
}
}
if (hint.Kind.HasValue)
{
var kind = hint.Kind.Value;
if ((kind & VariablePresentationHint.KindValue.Property) != 0)
{
flags |= ObjectValueFlags.Property;
}
if ((kind & VariablePresentationHint.KindValue.BaseClass) != 0)
{
flags |= ObjectValueFlags.Type;
}
if ((kind & VariablePresentationHint.KindValue.Class) != 0)
{
flags |= ObjectValueFlags.Type;
}
if ((kind & VariablePresentationHint.KindValue.InnerClass) != 0)
{
flags |= ObjectValueFlags.Type;
}
if ((kind & VariablePresentationHint.KindValue.Interface) != 0)
{
flags |= ObjectValueFlags.Type;
}
if ((kind & VariablePresentationHint.KindValue.MostDerivedClass) != 0)
{
flags |= ObjectValueFlags.Type;
}
if ((kind & VariablePresentationHint.KindValue.Data) != 0)
{
flags |= ObjectValueFlags.Variable;
}
}
if (hint.Visibility.HasValue)
{
var visibility = hint.Visibility.Value;
if ((visibility & VariablePresentationHint.VisibilityValue.Protected) != 0)
{
flags |= ObjectValueFlags.Protected;
}
if ((visibility & VariablePresentationHint.VisibilityValue.Internal) != 0)
{
flags |= ObjectValueFlags.Internal;
}
if ((visibility & VariablePresentationHint.VisibilityValue.Private) != 0)
{
flags |= ObjectValueFlags.Private;
}
if ((visibility & VariablePresentationHint.VisibilityValue.Public) != 0)
{
flags |= ObjectValueFlags.Public;
}
}
}
return(flags);
}
private EvaluateResponse Evaluate(string expression, string value, ValueFormat format)
{
ISampleVariableContainer container = null;
string variableName = null;
if (!expression.Contains("~"))
{
// Not a delimted expression = assume we're using the locals scope
container = this.localsScope;
variableName = expression;
}
else
{
List <string> evalParts = expression.Split('~').Select(p => p.Trim()).ToList();
variableName = evalParts.Last();
// Right now, we only support expressions that retrieve variables
foreach (string part in evalParts.Take(evalParts.Count - 1))
{
if (container == null)
{
container = this.AllScopes.FirstOrDefault(s => String.Equals(s.Name, part, StringComparison.Ordinal));
}
else
{
container = container.ChildContainers.FirstOrDefault(c => String.Equals(c.Name, part, StringComparison.Ordinal));
}
if (container == null)
{
throw new ProtocolException("Evaluation failed!");
}
}
}
SampleVariable variable = container.Variables.FirstOrDefault(v => String.Equals(v.Name, variableName, StringComparison.Ordinal));
if (variable == null)
{
throw new ProtocolException("Evaluation failed!");
}
if (value != null)
{
if (variable.IsReadOnly)
{
throw new ProtocolException("Expression is read-only.");
}
variable.SetValue(value);
}
VariablePresentationHint presentationHint = null;
if (variable.IsReadOnly)
{
presentationHint = new VariablePresentationHint
{
Attributes = VariablePresentationHint.AttributesValue.ReadOnly
};
}
return(new EvaluateResponse(
presentationHint: presentationHint,
result: variable.GetValue(format?.Hex ?? false),
variablesReference: variable.VariableReference,
type: variable.Type));
}
