public EvaluationDataItem(DkmVisualizedExpression expression, DkmEvaluationResult evalResult)
{
expression_ = expression;
evalResult_ = evalResult;
VisualizerRegistrar.TryCreateVisualizer(expression, out visualizer_);
}
void IDkmCustomVisualizer.EvaluateVisualizedExpression(DkmVisualizedExpression expression, out DkmEvaluationResult resultObject)
{
Debug.Print("UE4PV: EvaluateVisualizedExpression('{0}'/'{1}', [{2}])",
Utility.GetExpressionFullName(expression),
Utility.GetExpressionName(expression),
expression.TagValue
);
// Sanity check to confirm this is only being invoked for UObject types. @TODO: Remove eventually.
// Believe this method is only invoked on DkmRootVisualizedExpression instances, not children.
Debug.Assert(expression.VisualizerId == Guids.Visualizer.UObject);
UE4Visualizer visualizer = null;
bool result = UE4VisualizerRegistrar.TryCreateVisualizer(expression, out visualizer);
if(!result)
{
OnVisualizerMatchFailed(expression, out resultObject);
return;
}
// Evaluate the visualization result
DkmEvaluationResult eval = visualizer.EvaluationResult;
resultObject = eval;
// Associate the visualizer with the expression
expression.SetDataItem<ExpressionDataItem>(
DkmDataCreationDisposition.CreateAlways,
new ExpressionDataItem(visualizer)
);
}
public DkmEvaluationEnumAsyncResult(DkmEvaluationResult[] Items)
: this()
{
if (Items == null)
{
throw new ArgumentNullException();
}
this.Items = Items;
}
void IDkmCustomVisualizer.EvaluateVisualizedExpression(DkmVisualizedExpression expression, out DkmEvaluationResult resultObject)
{
BasicVisualizer visualizer = null;
DkmFailedEvaluationResult failureResult = null;
if (!TryGetRegisteredVisualizer(expression, out visualizer, out failureResult))
{
resultObject = failureResult;
return;
}
DkmEvaluationResult evalResult = visualizer.EvaluationResult;
EvaluationDataItem resultDataItem = new EvaluationDataItem(expression, evalResult);
expression.SetDataItem(DkmDataCreationDisposition.CreateAlways, resultDataItem);
string name = null;
string fullName = null;
Utility.GetExpressionName(expression, out name, out fullName);
if (evalResult.TagValue == DkmEvaluationResult.Tag.SuccessResult)
{
DkmSuccessEvaluationResult successResult = (DkmSuccessEvaluationResult)evalResult;
resultObject = DkmSuccessEvaluationResult.Create(
successResult.InspectionContext,
successResult.StackFrame,
name,
successResult.FullName,
successResult.Flags,
successResult.Value,
successResult.EditableValue,
successResult.Type,
successResult.Category,
successResult.Access,
successResult.StorageType,
successResult.TypeModifierFlags,
successResult.Address,
successResult.CustomUIVisualizers,
successResult.ExternalModules,
resultDataItem);
}
else
{
DkmFailedEvaluationResult failResult = (DkmFailedEvaluationResult)evalResult;
resultObject = DkmFailedEvaluationResult.Create(
failResult.InspectionContext,
failResult.StackFrame,
name,
fullName,
failResult.ErrorMessage,
failResult.Flags,
null);
return;
}
}
public DkmGetChildrenAsyncResult(DkmEvaluationResult[] InitialChildren, DkmEvaluationResultEnumContext EnumContext)
: this()
{
if (InitialChildren == null)
{
throw new ArgumentNullException();
}
this.InitialChildren = InitialChildren;
this.EnumContext = EnumContext;
}
void IDkmClrResultProvider.GetChildren(DkmEvaluationResult evaluationResult, DkmWorkList workList, int initialRequestSize, DkmInspectionContext inspectionContext, DkmCompletionRoutine<DkmGetChildrenAsyncResult> completionRoutine)
{
var dataItem = evaluationResult.GetDataItem<EvalResultDataItem>();
if (dataItem == null)
{
// We don't know about this result. Call next implementation
evaluationResult.GetChildren(workList, initialRequestSize, inspectionContext, completionRoutine);
return;
}
completionRoutine(GetChildren(inspectionContext, evaluationResult, dataItem, initialRequestSize));
}
void OnVisualizerMatchFailed(DkmVisualizedExpression expression, out DkmEvaluationResult result)
{
result = DkmFailedEvaluationResult.Create(
expression.InspectionContext,
expression.StackFrame,
Utility.GetExpressionName(expression),
Utility.GetExpressionFullName(expression),
String.Format("UE4PropVis: No visualizer is registered for VisualizerId {0}", expression.VisualizerId),
DkmEvaluationResultFlags.Invalid,
null
);
}
public static DebugCompilerContext CreateAssignmentContext(DkmEvaluationResult lValue, DkmClrInstructionAddress address, string expression)
{
MemoryStream input;
StreamReader reader;
CreateInputStream(expression, out input, out reader);
InspectionSession session = InspectionSession.GetInstance(lValue.InspectionSession);
InspectionScope scope = session.GetScope(address);
DebugCompilerContext context = new DebugCompilerContext(
null /* null because the context doesn't own the lifetime of the session */,
scope,
input,
reader,
typeof(AssignmentTranslator),
"$.M1",
null /* Generated locals is not applicable for assigments */,
lValue.FullName,
false /* "ArgumentsOnly" only applies to local variable query */);
context.InitializeSymbols();
return context;
}
public void EvaluateChildren(DkmChildVisualizedExpression[] output, int startIndex, out int numWritten)
{
numWritten = 0;
if (mode_ == ChildDisplayMode.Inline)
{
CreateDefaultEnumContext();
int count = ChildCount;
DkmEvaluationResult[] results = new DkmEvaluationResult[count];
expression_.GetItemsCallback(defEnumContext_, 0, count, out results);
for (int i = 0; i < count; ++i)
{
DkmSuccessEvaluationResult successResult = results[i] as DkmSuccessEvaluationResult;
DkmExpressionValueHome home = null;
if (successResult != null && successResult.Address != null) {
home = DkmPointerValueHome.Create(successResult.Address.Value);
} else {
home = DkmFakeValueHome.Create(0);
}
output[startIndex+i] = DkmChildVisualizedExpression.Create(
defEnumContext_.InspectionContext,
Guids.CustomVisualizer.ForceDefault,
expression_.SourceId,
defEnumContext_.StackFrame,
home,
results[i],
expression_,
(uint)startIndex,
null);
EvaluationDataItem originalDataItem = results[i].GetDataItem<EvaluationDataItem>();
}
numWritten = count;
}
else
numWritten = 1;
}
public unsafe void SetValueAsString(DkmEvaluationResult result, string value, int timeout, out string errorText) {
var pyEvalResult = result.GetDataItem<PyObjectEvaluationResult>();
if (pyEvalResult == null) {
Debug.Fail("SetValueAsString called on a DkmEvaluationResult without an associated PyObjectEvaluationResult.");
throw new NotSupportedException();
}
var proxy = pyEvalResult.ValueStore as IWritableDataProxy;
if (proxy == null) {
Debug.Fail("SetValueAsString called on a DkmEvaluationResult that does not correspond to an IWritableDataProxy.");
throw new InvalidOperationException();
}
errorText = null;
var process = result.StackFrame.Process;
var pyrtInfo = process.GetPythonRuntimeInfo();
var parserOptions = new ParserOptions { ErrorSink = new StringErrorSink() };
var parser = Parser.CreateParser(new StringReader(value), pyrtInfo.LanguageVersion, parserOptions);
var body = (ReturnStatement)parser.ParseTopExpression().Body;
errorText = parserOptions.ErrorSink.ToString();
if (!string.IsNullOrEmpty(errorText)) {
return;
}
var expr = body.Expression;
while (true) {
var parenExpr = expr as ParenthesisExpression;
if (parenExpr == null) {
break;
}
expr = parenExpr.Expression;
}
int sign;
expr = ForceExplicitSign(expr, out sign);
PyObject newObj = null;
var constExpr = expr as ConstantExpression;
if (constExpr != null) {
if (constExpr.Value == null) {
newObj = PyObject.None(process);
} else if (constExpr.Value is bool) {
// In 2.7, 'True' and 'False' are reported as identifiers, not literals, and are handled separately below.
newObj = PyBoolObject33.Create(process, (bool)constExpr.Value);
} else if (constExpr.Value is string) {
if (pyrtInfo.LanguageVersion <= PythonLanguageVersion.V27) {
newObj = PyUnicodeObject27.Create(process, (string)constExpr.Value);
} else {
newObj = PyUnicodeObject33.Create(process, (string)constExpr.Value);
}
} else if (constExpr.Value is AsciiString) {
newObj = PyBytesObject.Create(process, (AsciiString)constExpr.Value);
}
} else {
var unaryExpr = expr as UnaryExpression;
if (unaryExpr != null && sign != 0) {
constExpr = unaryExpr.Expression as ConstantExpression;
if (constExpr != null) {
if (constExpr.Value is BigInteger) {
newObj = PyLongObject.Create(process, (BigInteger)constExpr.Value * sign);
} else if (constExpr.Value is int) {
if (pyrtInfo.LanguageVersion <= PythonLanguageVersion.V27) {
newObj = PyIntObject.Create(process, (int)constExpr.Value * sign);
} else {
newObj = PyLongObject.Create(process, (int)constExpr.Value * sign);
}
} else if (constExpr.Value is double) {
newObj = PyFloatObject.Create(process, (double)constExpr.Value * sign);
} else if (constExpr.Value is Complex) {
newObj = PyComplexObject.Create(process, (Complex)constExpr.Value * sign);
}
}
} else {
var binExpr = expr as BinaryExpression;
if (binExpr != null && (binExpr.Operator == PythonOperator.Add || binExpr.Operator == PythonOperator.Subtract)) {
int realSign;
var realExpr = ForceExplicitSign(binExpr.Left, out realSign) as UnaryExpression;
int imagSign;
var imagExpr = ForceExplicitSign(binExpr.Right, out imagSign) as UnaryExpression;
if (realExpr != null && realSign != 0 && imagExpr != null && imagSign != 0) {
var realConst = realExpr.Expression as ConstantExpression;
var imagConst = imagExpr.Expression as ConstantExpression;
if (realConst != null && imagConst != null) {
var realVal = (realConst.Value as int? ?? realConst.Value as double?) as IConvertible;
var imagVal = imagConst.Value as Complex?;
if (realVal != null && imagVal != null) {
double real = realVal.ToDouble(null) * realSign;
double imag = imagVal.Value.Imaginary * imagSign * (binExpr.Operator == PythonOperator.Add ? 1 : -1);
newObj = PyComplexObject.Create(process, new Complex(real, imag));
}
}
}
} else {
if (pyrtInfo.LanguageVersion <= PythonLanguageVersion.V27) {
// 'True' and 'False' are not literals in 2.x, but we want to treat them as such.
var name = expr as NameExpression;
if (name != null) {
if (name.Name == "True") {
newObj = PyBoolObject27.Create(process, true);
} else if (name.Name == "False") {
newObj = PyBoolObject27.Create(process, false);
}
}
}
}
}
}
if (newObj != null) {
var oldObj = proxy.Read() as PyObject;
if (oldObj != null) {
// We can't free the original value without running some code in the process, and it may be holding heap locks.
// So don't decrement refcount now, but instead add it to the list of objects for TraceFunc to GC when it gets
// a chance to run next time.
_process.GetDataItem<PyObjectAllocator>().QueueForDecRef(oldObj);
}
newObj.ob_refcnt.Increment();
proxy.Write(newObj);
} else {
errorText = "Only boolean, numeric or string literals and None are supported.";
}
}
public string GetUnderlyingString(DkmEvaluationResult result) {
var rawResult = result.GetDataItem<RawEvaluationResult>();
if (rawResult != null && rawResult.Value is string) {
return (string)rawResult.Value;
}
var objResult = result.GetDataItem<PyObjectEvaluationResult>();
if (objResult == null) {
return null;
}
var str = objResult.ValueStore.Read() as IPyBaseStringObject;
return str.ToStringOrNull();
}
public void GetChildren(DkmEvaluationResult result, DkmWorkList workList, int initialRequestSize, DkmInspectionContext inspectionContext, DkmCompletionRoutine<DkmGetChildrenAsyncResult> completionRoutine) {
var asyncEvalResult = result.GetDataItem<CppViewEvaluationResult>();
if (asyncEvalResult != null) {
asyncEvalResult.GetChildren(result, workList, initialRequestSize, inspectionContext, completionRoutine);
return;
}
var pyEvalResult =
(IPythonEvaluationResult)result.GetDataItem<PyObjectEvaluationResult>() ??
(IPythonEvaluationResult)result.GetDataItem<GlobalsEvaluationResult>();
if (pyEvalResult != null) {
var childResults = pyEvalResult.GetChildren(this, result, inspectionContext);
completionRoutine(
new DkmGetChildrenAsyncResult(
new DkmEvaluationResult[0],
DkmEvaluationResultEnumContext.Create(
childResults.Count,
result.StackFrame,
inspectionContext,
new EvaluationResults { Results = childResults.ToArray() })));
return;
}
Debug.Fail("GetChildren called on an unsupported DkmEvaluationResult.");
throw new NotSupportedException();
}
public void GetChildren(DkmEvaluationResult result, DkmWorkList workList, int initialRequestSize, DkmInspectionContext inspectionContext, DkmCompletionRoutine<DkmGetChildrenAsyncResult> completionRoutine) {
CppEvaluationResult.GetChildren(workList, initialRequestSize, CppEvaluationResult.InspectionContext, (cppResult) => {
completionRoutine(cppResult);
});
}
public List<DkmEvaluationResult> GetChildren(ExpressionEvaluator exprEval, DkmEvaluationResult result, DkmInspectionContext inspectionContext) {
var stackFrame = result.StackFrame;
var cppEval = new CppExpressionEvaluator(inspectionContext, stackFrame);
var evalResults = new List<DkmEvaluationResult>();
foreach (var pair in Globals.ReadElements()) {
var name = pair.Key as IPyBaseStringObject;
if (name == null) {
continue;
}
var evalResult = exprEval.CreatePyObjectEvaluationResult(inspectionContext, stackFrame, null, new PythonEvaluationResult(pair.Value, name.ToString()), cppEval);
evalResults.Add(evalResult);
}
return evalResults.OrderBy(er => er.Name).ToList();
}
public List<DkmEvaluationResult> GetChildren(ExpressionEvaluator exprEval, DkmEvaluationResult result, DkmInspectionContext inspectionContext) {
var stackFrame = result.StackFrame;
var cppEval = new CppExpressionEvaluator(inspectionContext, stackFrame);
var obj = ValueStore.Read();
var evalResults = new List<DkmEvaluationResult>();
var reprOptions = new ReprOptions(inspectionContext);
var reprBuilder = new ReprBuilder(reprOptions);
if (DebuggerOptions.ShowCppViewNodes && !HasCppView) {
if (CppTypeName == null) {
// Try to guess the object's C++ type by looking at function pointers in its PyTypeObject. If they are pointing
// into a module for which symbols are available, C++ EE should be able to resolve them into something like
// "0x1e120d50 {python33_d.dll!list_dealloc(PyListObject *)}". If we are lucky, one of those functions will have
// the first argument declared as a strongly typed pointer, rather than PyObject* or void*.
CppTypeName = "PyObject";
CppTypeModuleName = null;
foreach (string methodField in _methodFields) {
var funcPtrEvalResult = cppEval.TryEvaluateObject(null, "PyObject", obj.Address, ".ob_type->" + methodField) as DkmSuccessEvaluationResult;
if (funcPtrEvalResult == null || funcPtrEvalResult.Value.IndexOf('{') < 0) {
continue;
}
var match = _cppFirstArgTypeFromFuncPtrRegex.Match(funcPtrEvalResult.Value);
string module = match.Groups["module"].Value;
string firstArgType = match.Groups["type"].Value;
if (firstArgType != "void" && firstArgType != "PyObject" && firstArgType != "_object") {
CppTypeName = firstArgType;
CppTypeModuleName = module;
break;
}
}
}
string cppExpr = CppExpressionEvaluator.GetExpressionForObject(CppTypeModuleName, CppTypeName, obj.Address, ",!");
var evalResult = DkmIntermediateEvaluationResult.Create(
inspectionContext, stackFrame, "[C++ view]", "{C++}" + cppExpr, cppExpr,
CppExpressionEvaluator.CppLanguage, stackFrame.Process.GetNativeRuntimeInstance(), null);
evalResults.Add(evalResult);
}
int i = 0;
foreach (var child in obj.GetDebugChildren(reprOptions).Take(MaxDebugChildren)) {
if (child.Name == null) {
reprBuilder.Clear();
reprBuilder.AppendFormat("[{0:PY}]", i++);
child.Name = reprBuilder.ToString();
}
DkmEvaluationResult evalResult;
if (child.ValueStore is IValueStore<PyObject>) {
evalResult = exprEval.CreatePyObjectEvaluationResult(inspectionContext, stackFrame, FullName, child, cppEval);
} else {
var value = child.ValueStore.Read();
reprBuilder.Clear();
reprBuilder.AppendLiteral(value);
string type = null;
if (Process.GetPythonRuntimeInfo().LanguageVersion <= PythonLanguageVersion.V27) {
_typeMapping2x.TryGetValue(value.GetType(), out type);
}
if (type == null) {
_typeMapping.TryGetValue(value.GetType(), out type);
}
var flags = DkmEvaluationResultFlags.ReadOnly;
if (value is string) {
flags |= DkmEvaluationResultFlags.RawString;
}
string childFullName = child.Name;
if (FullName != null) {
if (childFullName.EndsWith("()")) { // len()
childFullName = childFullName.Substring(0, childFullName.Length - 2) + "(" + FullName + ")";
} else {
if (!childFullName.StartsWith("[")) { // [0], ['fob'] etc
childFullName = "." + childFullName;
}
childFullName = FullName + childFullName;
}
}
evalResult = DkmSuccessEvaluationResult.Create(
inspectionContext, stackFrame, child.Name, childFullName, flags, reprBuilder.ToString(), null, type,
child.Category, child.AccessType, child.StorageType, child.TypeModifierFlags, null, null, null,
new RawEvaluationResult { Value = value });
}
evalResults.Add(evalResult);
}
return evalResults;
}
public void EvaluateVisualizedExpression(DkmVisualizedExpression visualizedExpression, out DkmEvaluationResult resultObject) {
var rootExpr = visualizedExpression as DkmRootVisualizedExpression;
if (rootExpr == null) {
Debug.Fail("PythonViewNativeVisualizer.EvaluateVisualizedExpression was given a visualized expression that is not a DkmRootVisualizedExpression.");
throw new NotSupportedException();
}
DkmEvaluationResult rawResult;
RawEvaluationResultHolder rawResultHolder;
using (var rawExpr = DkmLanguageExpression.Create(CppExpressionEvaluator.CppLanguage, DkmEvaluationFlags.ShowValueRaw, rootExpr.FullName + ",!", null)) {
rootExpr.EvaluateExpressionCallback(rootExpr.InspectionContext, rawExpr, rootExpr.StackFrame, out rawResult);
rawResultHolder = new RawEvaluationResultHolder { RawResult = rawResult };
rootExpr.SetDataItem(DkmDataCreationDisposition.CreateAlways, rawResultHolder);
}
var rawSuccessResult = rawResult as DkmSuccessEvaluationResult;
if (rawSuccessResult != null) {
resultObject = DkmSuccessEvaluationResult.Create(
rawResult.InspectionContext,
rawResult.StackFrame,
rootExpr.Name,
rawSuccessResult.FullName,
rawSuccessResult.Flags,
rawSuccessResult.Value,
rawSuccessResult.EditableValue,
rawSuccessResult.Type,
rawSuccessResult.Category,
rawSuccessResult.Access,
rawSuccessResult.StorageType,
rawSuccessResult.TypeModifierFlags,
rawSuccessResult.Address,
rawSuccessResult.CustomUIVisualizers,
rawSuccessResult.ExternalModules,
rawResultHolder);
return;
}
var rawFailedResult = rawResult as DkmFailedEvaluationResult;
if (rawFailedResult != null) {
resultObject = DkmFailedEvaluationResult.Create(
rawResult.InspectionContext,
rawResult.StackFrame,
rootExpr.Name,
rootExpr.FullName,
rawFailedResult.ErrorMessage,
rawFailedResult.Flags,
rawResultHolder);
return;
}
Debug.Fail("Raw evaluation result was neither DkmSuccessEvaluationResult nor DkmFailedEvaluationResult.");
throw new NotSupportedException();
}
private void GetChildrenAndContinue(EvalResultDataItem dataItem, DkmWorkList workList, DkmStackWalkFrame stackFrame, int initialRequestSize, DkmInspectionContext inspectionContext, DkmCompletionRoutine<DkmGetChildrenAsyncResult> completionRoutine)
{
var expansion = dataItem.Expansion;
var rows = ArrayBuilder<EvalResultDataItem>.GetInstance();
int index = 0;
if (expansion != null)
{
expansion.GetRows(this, rows, inspectionContext, dataItem, dataItem.Value, 0, initialRequestSize, visitAll: true, index: ref index);
}
var numRows = rows.Count;
Debug.Assert(index >= numRows);
Debug.Assert(initialRequestSize >= numRows);
var initialChildren = new DkmEvaluationResult[numRows];
var wl = new WorkList(workList, e => completionRoutine(DkmGetChildrenAsyncResult.CreateErrorResult(e)));
GetEvaluationResultsAndContinue(rows, initialChildren, 0, numRows, wl, inspectionContext, stackFrame,
() => wl.ContinueWith(
() =>
{
var enumContext = DkmEvaluationResultEnumContext.Create(index, stackFrame, inspectionContext, new EnumContextDataItem(dataItem));
completionRoutine(new DkmGetChildrenAsyncResult(initialChildren, enumContext));
rows.Free();
}));
wl.Execute();
}
// In VS 2015+, the injection of the child [Python view] node is handled in the PythonDkm.natvis, and the visualizer is only responsible
// for producing a DkmEvaluationResult for that node.
public void EvaluateVisualizedExpression(DkmVisualizedExpression visualizedExpression, out DkmEvaluationResult resultObject) {
resultObject = GetPythonView(visualizedExpression);
if (resultObject == null) {
resultObject = DkmFailedEvaluationResult.Create(
visualizedExpression.InspectionContext, visualizedExpression.StackFrame, "[Python view]",
null, "Python view is unavailable for this object", DkmEvaluationResultFlags.Invalid, null);
}
}
private void GetEvaluationResultsAndContinue(ArrayBuilder<EvalResultDataItem> rows, DkmEvaluationResult[] results, int index, int numRows, WorkList workList, DkmInspectionContext inspectionContext, DkmStackWalkFrame stackFrame, CompletionRoutine completionRoutine)
{
if (index < numRows)
{
CreateEvaluationResultAndContinue(rows[index], workList, inspectionContext, stackFrame,
result => workList.ContinueWith(
() =>
{
results[index] = result;
GetEvaluationResultsAndContinue(rows, results, index + 1, numRows, workList, inspectionContext, stackFrame, completionRoutine);
}));
}
else
{
completionRoutine();
}
}
private DkmGetChildrenAsyncResult GetChildren(DkmInspectionContext inspectionContext, DkmEvaluationResult evaluationResult, EvalResultDataItem dataItem, int initialRequestSize)
{
var expansion = dataItem.Expansion;
var builder = ArrayBuilder<DkmEvaluationResult>.GetInstance();
int index = 0;
if (expansion != null)
{
expansion.GetRows(this, builder, inspectionContext, dataItem, dataItem.Value, 0, initialRequestSize, visitAll: true, index: ref index);
}
var rows = builder.ToArrayAndFree();
Debug.Assert(index >= rows.Length);
Debug.Assert(initialRequestSize >= rows.Length);
var enumContext = DkmEvaluationResultEnumContext.Create(index, evaluationResult.StackFrame, evaluationResult.InspectionContext, new EnumContextDataItem(dataItem));
return new DkmGetChildrenAsyncResult(rows, enumContext);
}
public CppEvaluationException(DkmEvaluationResult evalResult = null) {
EvaluationResult = evalResult;
}
public void UseDefaultEvaluationBehavior(DkmVisualizedExpression visualizedExpression, out bool useDefaultEvaluationBehavior, out DkmEvaluationResult defaultEvaluationResult) {
// If it is a child expression, we want to fall back to default visualizer ...
var childExpr = visualizedExpression as DkmChildVisualizedExpression;
if (childExpr != null) {
var childResult = childExpr.EvaluationResult;
// ... unless the child is also of a type which uses this visualizer, in which case just recurse.
var rawResultHolder = childResult.GetDataItem<RawEvaluationResultHolder>();
if (rawResultHolder == null) {
useDefaultEvaluationBehavior = true;
defaultEvaluationResult = childResult;
return;
}
}
useDefaultEvaluationBehavior = false;
defaultEvaluationResult = null;
}
public EvaluationException(DkmEvaluationResult result)
{
result_ = result;
}
private void DepthFirstSearchInternal(ArrayBuilder<DkmEvaluationResult> builder, DkmEvaluationResult curr, int depth, int maxDepth)
{
Assert.InRange(depth, 0, maxDepth);
builder.Add(curr);
var childDepth = depth + 1;
if (childDepth <= maxDepth)
{
foreach (var child in GetChildren(curr))
{
DepthFirstSearchInternal(builder, child, childDepth, maxDepth);
}
}
}
string IDkmClrResultProvider.GetUnderlyingString(DkmEvaluationResult result)
{
try
{
var dataItem = result.GetDataItem<EvalResultDataItem>();
if (dataItem == null)
{
// We don't know about this result. Call next implementation
return result.GetUnderlyingString();
}
return dataItem.Value?.GetUnderlyingString(result.InspectionContext);
}
catch (Exception e) when (ExpressionEvaluatorFatalError.CrashIfFailFastEnabled(e))
{
throw ExceptionUtilities.Unreachable;
}
}
public void UseDefaultEvaluationBehavior(DkmVisualizedExpression visualizedExpression, out bool useDefaultEvaluationBehavior, out DkmEvaluationResult defaultEvaluationResult) {
useDefaultEvaluationBehavior = true;
defaultEvaluationResult = GetPythonView(visualizedExpression);
if (defaultEvaluationResult == null) {
throw new NotSupportedException();
}
}
private void GetItemsAndContinue(EvalResultDataItem dataItem, DkmWorkList workList, int startIndex, int count, DkmInspectionContext inspectionContext, DkmCompletionRoutine<DkmEvaluationEnumAsyncResult> completionRoutine)
{
var expansion = dataItem.Expansion;
var value = dataItem.Value;
var rows = ArrayBuilder<EvalResultDataItem>.GetInstance();
if (expansion != null)
{
int index = 0;
expansion.GetRows(this, rows, inspectionContext, dataItem, value, startIndex, count, visitAll: false, index: ref index);
}
var numRows = rows.Count;
Debug.Assert(count >= numRows);
var results = new DkmEvaluationResult[numRows];
var wl = new WorkList(workList, e => completionRoutine(DkmEvaluationEnumAsyncResult.CreateErrorResult(e)));
GetEvaluationResultsAndContinue(rows, results, 0, numRows, wl, inspectionContext, value.StackFrame,
() => wl.ContinueWith(
() =>
{
completionRoutine(new DkmEvaluationEnumAsyncResult(results));
rows.Free();
}));
wl.Execute();
}
private IReadOnlyList<DkmEvaluationResult> DepthFirstSearch(DkmEvaluationResult root, int maxDepth)
{
var builder = ArrayBuilder<DkmEvaluationResult>.GetInstance();
DepthFirstSearchInternal(builder, root, 0, maxDepth);
return builder.ToImmutableAndFree();
}
public DkmEvaluationResult[] GetAllProperties()
{
DkmEvaluationResult[] props = new DkmEvaluationResult[prop_evals_.Count];
int idx = 0;
foreach(var eval in prop_evals_)
{
props[idx] = eval.Value;
++idx;
}
return props;
}
public void LazyExpansion()
{
var rootExpr = "new byte[10, 1000, 1000]";
var parenthesizedExpr = string.Format("({0})", rootExpr);
var value = CreateDkmClrValue(new byte[10, 1000, 1000]); // Array with 10M elements
var evalResults = new DkmEvaluationResult[100]; // 100 distinct evaluations of the array
for (int i = 0; i < evalResults.Length; i++)
{
var evalResult = FormatResult(rootExpr, value);
evalResults[i] = evalResult;
// Expand a subset.
int offset = i * 100 * 1000;
DkmEvaluationResultEnumContext enumContext;
GetChildren(evalResult, 0, null, out enumContext);
var items = GetItems(enumContext, offset, 2);
var indices1 = string.Format("{0}, {1}, {2}", offset / 1000000, (offset % 1000000) / 1000, 0);
var indices2 = string.Format("{0}, {1}, {2}", (offset + 1) / 1000000, ((offset + 1) % 1000000) / 1000, 1);
Verify(items,
EvalResult(string.Format("[{0}]", indices1), "0", "byte", string.Format("{0}[{1}]", parenthesizedExpr, indices1)),
EvalResult(string.Format("[{0}]", indices2), "0", "byte", string.Format("{0}[{1}]", parenthesizedExpr, indices2)));
}
}
