public override void PrepareExpansion(out DkmEvaluationResultEnumContext enumContext) { // First, default expansion // @TODO: Calling this both in EvaluateExpressionResult, and from UseDefaultEvaluationBehavior // in the component. Be good if we can somehow test if this is actually redoing the evaluation, // or just returning the existing one. var eval = DefaultEE.DefaultEval(expression_, true); DkmEvaluationResult[] children; DkmEvaluationResultEnumContext default_enum_ctx; expression_.GetChildrenCallback(eval, 0, expression_.InspectionContext, out children, out default_enum_ctx); // Now any custom additions to the expansion int custom_children = 0; // Need to determine if we should display the property list child DeterminePropertyListVisibility(); if(IsPropertyListShown) { custom_children++; } // Create an aggregate enumeration context, with the length of the default enum, plus what we are adding on. // Store the default enumeration context inside it as a data item. enumContext = DkmEvaluationResultEnumContext.Create( default_enum_ctx.Count + custom_children, expression_.StackFrame, expression_.InspectionContext, new DefaultEnumContextDataItem(default_enum_ctx) ); }
public static DkmEvaluationResultEnumContext Create(int Count, DkmStackWalkFrame StackFrame, DkmInspectionContext InspectionContext, DkmDataItem DataItem) { var enumContext = new DkmEvaluationResultEnumContext(Count, InspectionContext); if (DataItem != null) { enumContext.SetDataItem(DkmDataCreationDisposition.CreateNew, DataItem); } return enumContext; }
public DkmGetChildrenAsyncResult(DkmEvaluationResult[] InitialChildren, DkmEvaluationResultEnumContext EnumContext) : this() { if (InitialChildren == null) { throw new ArgumentNullException(); } this.InitialChildren = InitialChildren; this.EnumContext = EnumContext; }
public DkmGetChildrenAsyncResult(DkmEvaluationResult[] InitialChildren, DkmEvaluationResultEnumContext EnumContext) : this() { if (InitialChildren == null) { throw new ArgumentNullException(); } this.InitialChildren = InitialChildren; this.EnumContext = EnumContext; }
public static DkmEvaluationResultEnumContext Create(int Count, DkmStackWalkFrame StackFrame, DkmInspectionContext InspectionContext, DkmDataItem DataItem) { var enumContext = new DkmEvaluationResultEnumContext(Count, InspectionContext); if (DataItem != null) { enumContext.SetDataItem(DkmDataCreationDisposition.CreateNew, DataItem); } return(enumContext); }
void IDkmCustomVisualizer.GetChildren(DkmVisualizedExpression expression, int initialRequestSize, DkmInspectionContext inspectionContext, out DkmChildVisualizedExpression[] initialChildren, out DkmEvaluationResultEnumContext enumContext) { Debug.Print("UE4PV: GetChildren('{0}'/'{1}', [{2}, {3}])", Utility.GetExpressionFullName(expression), Utility.GetExpressionName(expression), expression.TagValue, expression.VisualizerId ); var data_item = expression.GetDataItem<ExpressionDataItem>(); var visualizer = data_item.Visualizer; Debug.Assert(visualizer != null); visualizer.PrepareExpansion(out enumContext); initialChildren = new DkmChildVisualizedExpression[0]; }
public abstract void PrepareExpansion(out DkmEvaluationResultEnumContext enumContext);
void IDkmClrResultProvider.GetItems(DkmEvaluationResultEnumContext enumContext, DkmWorkList workList, int startIndex, int count, DkmCompletionRoutine<DkmEvaluationEnumAsyncResult> completionRoutine) { try { var dataItem = enumContext.GetDataItem<EnumContextDataItem>(); if (dataItem == null) { // We don't know about this result. Call next implementation enumContext.GetItems(workList, startIndex, count, completionRoutine); return; } completionRoutine(GetItems(enumContext.InspectionContext, dataItem.EvalResultDataItem, startIndex, count)); } catch (Exception e) when (ExpressionEvaluatorFatalError.CrashIfFailFastEnabled(e)) { throw ExceptionUtilities.Unreachable; } }
public void GetItems(DkmVisualizedExpression visualizedExpression, DkmEvaluationResultEnumContext enumContext, int startIndex, int count, out DkmChildVisualizedExpression[] items) { if (count == 0) { items = new DkmChildVisualizedExpression[0]; return; } var rawContextData = enumContext.GetDataItem<RawEnumContextData>(); var rawContext = rawContextData != null ? rawContextData.RawContext : enumContext; var result = new List<DkmChildVisualizedExpression>(count); if (rawContextData != null && rawContextData.PythonView != null) { if (startIndex == 0) { result.Add(rawContextData.PythonView); --count; } else { --startIndex; } } DkmEvaluationResult[] rawItems; visualizedExpression.GetItemsCallback(rawContext, startIndex, count, out rawItems); for (int i = 0; i < rawItems.Length; ++i) { var rawItem = rawItems[i]; var rawSuccessItem = rawItem as DkmSuccessEvaluationResult; DkmExpressionValueHome home = null; if (rawSuccessItem != null && rawSuccessItem.Address != null) { home = DkmPointerValueHome.Create(rawSuccessItem.Address.Value); } else { home = DkmFakeValueHome.Create(0); } var item = DkmChildVisualizedExpression.Create( visualizedExpression.InspectionContext, visualizedExpression.VisualizerId, visualizedExpression.SourceId, visualizedExpression.StackFrame, home, rawItem, visualizedExpression, (uint)(startIndex + i), rawItem.GetDataItem<RawEvaluationResultHolder>()); result.Add(item); } items = result.ToArray(); }
public void GetChildren(DkmVisualizedExpression visualizedExpression, int initialRequestSize, DkmInspectionContext inspectionContext, out DkmChildVisualizedExpression[] initialChildren, out DkmEvaluationResultEnumContext enumContext) { var rawResultHolder = visualizedExpression.GetDataItem<RawEvaluationResultHolder>(); if (rawResultHolder == null) { Debug.Fail("PythonViewNativeVisualizer.GetChildren passed a visualized expression that does not have an associated RawEvaluationResultHolder."); throw new NotSupportedException(); } var rawResult = rawResultHolder.RawResult; DkmEvaluationResult[] rawInitialChildren; DkmEvaluationResultEnumContext rawEnumContext; visualizedExpression.GetChildrenCallback(rawResult, 0, inspectionContext, out rawInitialChildren, out rawEnumContext); initialChildren = new DkmChildVisualizedExpression[0]; enumContext = rawEnumContext; if (DebuggerOptions.ShowPythonViewNodes) { var pythonViewEvalResult = GetPythonView(visualizedExpression); var pythonView = DkmChildVisualizedExpression.Create( visualizedExpression.InspectionContext, visualizedExpression.VisualizerId, visualizedExpression.SourceId, visualizedExpression.StackFrame, visualizedExpression.ValueHome, pythonViewEvalResult, visualizedExpression, (uint)rawEnumContext.Count, null); if (pythonView != null) { enumContext = DkmEvaluationResultEnumContext.Create( rawEnumContext.Count + 1, rawEnumContext.StackFrame, rawEnumContext.InspectionContext, new RawEnumContextData { RawContext = rawEnumContext, PythonView = pythonView }); } } }
public void GetItems(DkmVisualizedExpression visualizedExpression, DkmEvaluationResultEnumContext enumContext, int startIndex, int count, out DkmChildVisualizedExpression[] items) { throw new NotImplementedException(); }
void IDkmCustomVisualizer.GetItems(DkmVisualizedExpression expression, DkmEvaluationResultEnumContext enumContext, int startIndex, int count, out DkmChildVisualizedExpression[] items) { EvaluationDataItem dataItem = expression.GetDataItem<EvaluationDataItem>(); if (dataItem == null) { Debug.Fail("DebugComponent.GetItems passed a visualized expression that does not have an associated ExpressionDataItem."); throw new NotSupportedException(); } items = dataItem.Visualizer.GetChildItems(startIndex, count); }
public override void GetChildItems(DkmEvaluationResultEnumContext enumContext, int start, int count, out DkmChildVisualizedExpression[] items) { var props = GetAllProperties(); int total_num_props = props.Length; int end_idx = Math.Min(start + count, total_num_props); int num_to_return = end_idx - start; items = new DkmChildVisualizedExpression[num_to_return]; for (int idx = start, out_idx = 0; idx < end_idx; ++idx, ++out_idx) { // We want to construct our own visualized expression from the eval. var eval = props[idx] as DkmSuccessEvaluationResult; // @TODO: Perhaps allow for failed evaluations and display anyway with unknown value?? Debug.Assert(eval != null); DkmExpressionValueHome home; if (eval.Address != null) { home = DkmPointerValueHome.Create(eval.Address.Value); } else { home = DkmFakeValueHome.Create(0); } var expr = DkmChildVisualizedExpression.Create( expression_.InspectionContext, // @TODO: This is weird... seems to affect whether we get callback. // Obviously the properties can be of any type, UObject or not. // Perhaps best to put back the guid for PropertyValue, even though we don't really need to use it. Guids.Visualizer.PropertyValue,//Guids.Visualizer.UObject,//Guids.Visualizer.PropertyList, // Seems that in order for these to be passed back to the EE for default expansion, they need to be given // the SourceId from the originally received root expression. PropListExpression.Parent.SourceId, expression_.StackFrame, home, eval, expression_, (uint)idx, null // Don't associate any data with the expression. If the EE calls back to us to expand it, we'll just tell it to use default expansion. ); items[out_idx] = expr; } }
public void GetItems(DkmEvaluationResultEnumContext enumContext, DkmWorkList workList, int startIndex, int count, DkmCompletionRoutine<DkmEvaluationEnumAsyncResult> completionRoutine) { var evalResults = enumContext.GetDataItem<EvaluationResults>(); if (evalResults == null) { Debug.Fail("GetItems called on a DkmEvaluationResultEnumContext without an associated EvaluationResults."); throw new NotSupportedException(); } var result = evalResults.Results.Skip(startIndex).Take(count).ToArray(); completionRoutine(new DkmEvaluationEnumAsyncResult(result)); }
public abstract void GetChildItems(DkmEvaluationResultEnumContext enumContext, int start, int count, out DkmChildVisualizedExpression[] items);
public override void GetChildItems(DkmEvaluationResultEnumContext enumContext, int start, int count, out DkmChildVisualizedExpression[] items) { // Cap the requested number to the total remaining from startIndex count = Math.Min(count, enumContext.Count - start); items = new DkmChildVisualizedExpression[count]; uint idx = 0; // Retrieve the default expansion enum context var default_data = enumContext.GetDataItem<DefaultEnumContextDataItem>(); if (start < default_data.Context.Count) { // Requesting default children int default_count = Math.Min(count, default_data.Context.Count - start); DkmEvaluationResult[] default_evals; expression_.GetItemsCallback(default_data.Context, start, default_count, out default_evals); for (int dft_idx = 0; dft_idx < default_count; ++dft_idx, ++idx) { DkmSuccessEvaluationResult success_eval = default_evals[dft_idx] as DkmSuccessEvaluationResult; DkmExpressionValueHome home = null; if (success_eval != null && success_eval.Address != null) { home = DkmPointerValueHome.Create(success_eval.Address.Value); } else { home = DkmFakeValueHome.Create(0); } items[idx] = DkmChildVisualizedExpression.Create( enumContext.InspectionContext, expression_.VisualizerId, // @TODO: Check this is what we want. Will we get callbacks for it, regardless of its type? expression_.SourceId, enumContext.StackFrame, home, default_evals[dft_idx], expression_, (uint)start, null ); } } if (start + count > default_data.Context.Count) { // Requesting custom children // @NOTE: Currently just assuming only 1 custom child (prop list) and hard coding as such. // DkmSuccessEvaluationResult.ExtractFromProperty(IDebugProperty3!!!!!!!) ............................................... // @NOTE: Had thought could just create an expression with a null evaluation // inside it, and by giving it a visualizer guid, the system would call back // to us to evaluate the expression. Seems not to work though, I guess because the // visualizer guid identifies the visualizer but not the containing component, // and since the expression itself doesn't have a type, it can't know that it // should call our component. DkmEvaluationResult eval = DkmSuccessEvaluationResult.Create( enumContext.InspectionContext, enumContext.StackFrame, Resources.UE4PropVis.IDS_DISP_BLUEPRINTPROPERTIES, Resources.UE4PropVis.IDS_DISP_BLUEPRINTPROPERTIES, DkmEvaluationResultFlags.ReadOnly | DkmEvaluationResultFlags.Expandable, "", // @TODO: something like "[<count> properties]" null, "", // Type column DkmEvaluationResultCategory.Other, DkmEvaluationResultAccessType.None, DkmEvaluationResultStorageType.None, DkmEvaluationResultTypeModifierFlags.None, null, null, null, null ); // This child is just for organization and does not correspond to anything in memory. DkmExpressionValueHome valueHome = DkmFakeValueHome.Create(0); var prop_list_expr = DkmChildVisualizedExpression.Create( enumContext.InspectionContext, Guids.Visualizer.PropertyList, // Associate the expression with ourselves, since we created it Guids.Component.VisualizerComponent, enumContext.StackFrame, valueHome, eval, expression_, idx, null ); // Create a visualizer for the property list, and attach it to the expression. var prop_list_visualizer = new PropertyListVisualizer(prop_list_expr, access_ctx_); prop_list_expr.SetDataItem(DkmDataCreationDisposition.CreateAlways, new ExpressionDataItem(prop_list_visualizer)); items[idx] = prop_list_expr; } }
void IDkmCustomVisualizer.GetItems(DkmVisualizedExpression expression, DkmEvaluationResultEnumContext enumContext, int startIndex, int count, out DkmChildVisualizedExpression[] items) { var data_item = expression.GetDataItem<ExpressionDataItem>(); var visualizer = data_item.Visualizer; Debug.Assert(visualizer != null); visualizer.GetChildItems(enumContext, startIndex, count, out items); }
public DefaultEnumContextDataItem(DkmEvaluationResultEnumContext ctx) { default_enum_ctx_ = ctx; }
void IDkmClrResultProvider.GetItems(DkmEvaluationResultEnumContext enumContext, DkmWorkList workList, int startIndex, int count, DkmCompletionRoutine<DkmEvaluationEnumAsyncResult> completionRoutine) { var enumContextDataItem = enumContext.GetDataItem<EnumContextDataItem>(); if (enumContextDataItem == null) { // We don't know about this result. Call next implementation enumContext.GetItems(workList, startIndex, count, completionRoutine); return; } var evaluationResult = enumContextDataItem.Result; var dataItem = evaluationResult.GetDataItem<EvalResultDataItem>(); var expansion = dataItem.Expansion; if (expansion == null) { completionRoutine(new DkmEvaluationEnumAsyncResult(new DkmEvaluationResult[0])); return; } var inspectionContext = enumContext.InspectionContext; var rows = ArrayBuilder<EvalResult>.GetInstance(); int index = 0; expansion.GetRows(this, rows, inspectionContext, dataItem, dataItem.Value, startIndex, count, visitAll: false, index: ref index); var numRows = rows.Count; Debug.Assert(count >= numRows); var results = new DkmEvaluationResult[numRows]; CompletionRoutine<Exception> onException = e => completionRoutine(DkmEvaluationEnumAsyncResult.CreateErrorResult(e)); var wl = new WorkList(workList, onException); wl.ContinueWith(() => GetEvaluationResultsAndContinue(evaluationResult, rows, results, 0, numRows, wl, inspectionContext, () => wl.ContinueWith( () => { completionRoutine(new DkmEvaluationEnumAsyncResult(results)); rows.Free(); }), onException)); }
public DefaultChildEvaluator(DkmVisualizedExpression expression, ChildDisplayMode mode) { this.mode_ = mode; this.expression_ = expression; this.defEnumContext_ = null; }
void IDkmClrResultProvider.GetItems(DkmEvaluationResultEnumContext enumContext, DkmWorkList workList, int startIndex, int count, DkmCompletionRoutine<DkmEvaluationEnumAsyncResult> completionRoutine) { enumContext.GetItems(workList, startIndex, count, completionRoutine); }
void IDkmClrResultProvider.GetItems(DkmEvaluationResultEnumContext enumContext, DkmWorkList workList, int startIndex, int count, DkmCompletionRoutine<DkmEvaluationEnumAsyncResult> completionRoutine) { var dataItem = enumContext.GetDataItem<EnumContextDataItem>(); if (dataItem == null) { // We don't know about this result. Call next implementation enumContext.GetItems(workList, startIndex, count, completionRoutine); return; } GetItemsAndContinue(dataItem.EvalResultDataItem, workList, startIndex, count, enumContext.InspectionContext, completionRoutine); }
public void GetChildren(DkmVisualizedExpression visualizedExpression, int initialRequestSize, DkmInspectionContext inspectionContext, out DkmChildVisualizedExpression[] initialChildren, out DkmEvaluationResultEnumContext enumContext) { throw new NotImplementedException(); }
public override void PrepareExpansion(out DkmEvaluationResultEnumContext enumContext) { EvaluateProperties(); enumContext = DkmEvaluationResultEnumContext.Create( GetNumProperties(), expression_.StackFrame, expression_.InspectionContext, null ); }
void IDkmCustomVisualizer.GetChildren(DkmVisualizedExpression expression, int initialRequestSize, DkmInspectionContext inspectionContext, out DkmChildVisualizedExpression[] initialChildren, out DkmEvaluationResultEnumContext enumContext) { EvaluationDataItem dataItem = expression.GetDataItem<EvaluationDataItem>(); if (dataItem == null) { Debug.Fail("DebugComponent.GetChildren passed a visualized expression that does not have an associated ExpressionDataItem."); throw new NotSupportedException(); } initialChildren = new DkmChildVisualizedExpression[0]; enumContext = DkmEvaluationResultEnumContext.Create( dataItem.Visualizer.ChildElementCount, expression.StackFrame, expression.InspectionContext, null); }