internal string ExecuteExpression(string expression, DkmStackContext stackContext, DkmStackWalkFrame input, bool allowZero)
{
var compilerId = new DkmCompilerId(DkmVendorId.Microsoft, DkmLanguageId.Cpp);
var language = DkmLanguage.Create("C++", compilerId);
var languageExpression = DkmLanguageExpression.Create(language, DkmEvaluationFlags.None, expression, null);
var inspectionContext = DkmInspectionContext.Create(stackContext.InspectionSession, input.RuntimeInstance, stackContext.Thread, 200, DkmEvaluationFlags.None, DkmFuncEvalFlags.None, 10, language, null);
var workList = DkmWorkList.Create(null);
string resultText = null;
inspectionContext.EvaluateExpression(workList, languageExpression, input, res =>
{
if (res.ErrorCode == 0)
{
var result = res.ResultObject as DkmSuccessEvaluationResult;
if (result != null && result.TagValue == DkmEvaluationResult.Tag.SuccessResult && (allowZero || result.Address.Value != 0))
{
resultText = result.Value;
}
res.ResultObject.Close();
}
});
workList.Execute();
return(resultText);
}
public static DkmEvaluationResult DefaultEval(string text, DkmVisualizedExpression expression, bool raw_format)
{
if (raw_format && text.Length > 0)
{
// Ensure we have the format specifier for raw format, to prevent the evaluator just calling back again to us.
text = text.TrimEnd(new char[] { ' ' });
if (text.Last() == ',')
{
text += '!';
}
else
{
text += ",!";
}
}
var LangExpr = DkmLanguageExpression.Create(CppLanguage, DkmEvaluationFlags.None, text, null);
DkmEvaluationResult result;
try
{
expression.EvaluateExpressionCallback(expression.InspectionContext, LangExpr, expression.StackFrame, out result);
}
catch (Exception e)
{
result = null;
}
return(result);
}
internal static DkmEvaluationResult ExecuteRawExpression(string expression, DkmInspectionSession inspectionSession, DkmThread thread, DkmStackWalkFrame input, DkmRuntimeInstance runtimeInstance, DkmEvaluationFlags flags)
{
var compilerId = new DkmCompilerId(DkmVendorId.Microsoft, DkmLanguageId.Cpp);
var language = DkmLanguage.Create("C++", compilerId);
var languageExpression = DkmLanguageExpression.Create(language, DkmEvaluationFlags.None, expression, null);
var inspectionContext = DkmInspectionContext.Create(inspectionSession, runtimeInstance, thread, 200, flags, DkmFuncEvalFlags.None, 10, language, null, null, DkmCompiledVisualizationDataPriority.None, null, workerConnection);
var workList = DkmWorkList.Create(null);
try
{
DkmEvaluationResult result = null;
inspectionContext.EvaluateExpression(workList, languageExpression, input, res =>
{
if (res.ErrorCode == 0)
{
result = res.ResultObject;
}
});
workList.Execute();
return(result);
}
catch (OperationCanceledException)
{
return(null);
}
}
public static DkmEvaluationResult DefaultEval(string text, DkmVisualizedExpression expression, bool raw_format)
{
if (raw_format && text.Length > 0)
{
// Ensure we have the format specifier for raw format, to prevent the evaluator just calling back again to us.
int comma = text.IndexOf(',');
if (comma == -1)
{
text += ",!";
}
else
{
int raw = text.IndexOf('!', comma + 1);
if (raw == -1)
{
text += "!";
}
}
}
var LangExpr = DkmLanguageExpression.Create(CppLanguage, DkmEvaluationFlags.None, text, null);
DkmEvaluationResult result;
try
{
expression.EvaluateExpressionCallback(expression.InspectionContext, LangExpr, expression.StackFrame, out result);
}
catch (Exception e)
{
result = null;
}
return(result);
}
private DkmLanguageExpression AddFuncEval(
DkmWorkList workList,
string funcEval,
Action <DkmEvaluationResult> evalResult)
{
Debug.Assert(workList != null && !string.IsNullOrEmpty(funcEval), "Arguments should not be null");
Debug.WriteLine($"Creating func-eval: '{funcEval}'");
// Create the evaluation to add
var langExpr = DkmLanguageExpression.Create(
this.inspectionContext.Language,
DkmEvaluationFlags.None,
funcEval,
null);
this.inspectionContext.EvaluateExpression(
workList,
langExpr,
this.inspectionContext.Thread.GetTopStackFrame(),
delegate(DkmEvaluateExpressionAsyncResult asyncResult)
{
evalResult(asyncResult.ResultObject);
});
return(langExpr);
}
public static DkmEvaluationResult Evaluate(DkmVisualizedExpression expr, DkmEvaluationFlags flags, string text, DkmDataItem data)
{
using (DkmLanguageExpression vexpr = DkmLanguageExpression.Create(CppLanguage, flags, text, data))
{
DkmEvaluationResult result = null;
expr.EvaluateExpressionCallback(expr.InspectionContext, vexpr, expr.StackFrame, out result);
return(result);
}
}
public DkmEvaluationResult TryEvaluate(string expr)
{
using (var cppExpr = DkmLanguageExpression.Create(CppLanguage, DkmEvaluationFlags.NoSideEffects, expr, null)) {
DkmEvaluationResult cppEvalResult = null;
var cppWorkList = DkmWorkList.Create(null);
_cppInspectionContext.EvaluateExpression(cppWorkList, cppExpr, _nativeFrame, (result) => {
cppEvalResult = result.ResultObject;
});
cppWorkList.Execute();
return(cppEvalResult);
}
}
internal static string ExecuteExpression(string expression, DkmInspectionSession inspectionSession, DkmThread thread, DkmStackWalkFrame input, DkmEvaluationFlags flags, bool allowZero, out ulong address)
{
if (Log.instance != null)
{
Log.instance.Verbose($"ExecuteExpression begin evaluation of '{expression}'");
}
var compilerId = new DkmCompilerId(DkmVendorId.Microsoft, DkmLanguageId.Cpp);
var language = DkmLanguage.Create("C++", compilerId);
var languageExpression = DkmLanguageExpression.Create(language, DkmEvaluationFlags.None, expression, null);
var inspectionContext = DkmInspectionContext.Create(inspectionSession, input.RuntimeInstance, thread, 200, flags, DkmFuncEvalFlags.None, 10, language, null, null, DkmCompiledVisualizationDataPriority.None, null, workerConnection);
var workList = DkmWorkList.Create(null);
try
{
string resultText = null;
ulong resultAddress = 0;
inspectionContext.EvaluateExpression(workList, languageExpression, input, res =>
{
if (res.ErrorCode == 0)
{
var result = res.ResultObject as DkmSuccessEvaluationResult;
if (result != null && result.TagValue == DkmEvaluationResult.Tag.SuccessResult && (allowZero || result.Address.Value != 0))
{
resultText = result.Value;
resultAddress = result.Address.Value;
}
res.ResultObject.Close();
}
});
workList.Execute();
if (Log.instance != null)
{
Log.instance.Verbose($"ExecuteExpression completed");
}
address = resultAddress;
return(resultText);
}
catch (OperationCanceledException)
{
address = 0;
return(null);
}
}
/// <summary>
/// Returns child elements of previous evaluation.
/// </summary>
public void GetItems(DkmVisualizedExpression visualizedExpression, DkmEvaluationResultEnumContext enumContext, int startIndex, int count, out DkmChildVisualizedExpression[] items)
{
// Check if we want to use passthrough visualizer
PassThroughVisualizer passThroughVisualizer = enumContext.GetDataItem <PassThroughVisualizer>();
if (passThroughVisualizer != null)
{
passThroughVisualizer.GetItems(visualizedExpression, enumContext, startIndex, count, out items);
return;
}
// Execute our regular visualizer
VSCustomVisualizerEvaluator evaluator = visualizedExpression.GetDataItem <VSCustomVisualizerEvaluator>();
IResultVisualizer[] itemsAsResults = evaluator.ResultVisualizer.Children.Skip(startIndex).Take(count).ToArray();
items = new DkmChildVisualizedExpression[itemsAsResults.Length];
for (int i = 0; i < items.Length; i++)
{
IResultVisualizer item = itemsAsResults[i];
DkmEvaluationResultCategory category;
switch (item.DataType)
{
case CompletionDataType.Class:
category = DkmEvaluationResultCategory.Class;
break;
case CompletionDataType.Property:
case CompletionDataType.StaticProperty:
category = DkmEvaluationResultCategory.Property;
break;
case CompletionDataType.Event:
category = DkmEvaluationResultCategory.Event;
break;
case CompletionDataType.Method:
category = DkmEvaluationResultCategory.Method;
break;
case CompletionDataType.Enum:
case CompletionDataType.EnumValue:
case CompletionDataType.Keyword:
case CompletionDataType.Namespace:
case CompletionDataType.StaticClass:
case CompletionDataType.StaticEvent:
case CompletionDataType.StaticMethod:
case CompletionDataType.StaticVariable:
case CompletionDataType.Unknown:
case CompletionDataType.Variable:
default:
category = DkmEvaluationResultCategory.Data;
break;
}
DkmExpressionValueHome valueHome = visualizedExpression.ValueHome;
ulong address = 0;
string fullName = string.Empty;
string typeName = null;
try
{
if (item.Value is Variable variable)
{
address = variable.GetPointerAddress();
typeName = variable.GetCodeType().Name;
fullName = $"*(({typeName}*)0x{address:X})";
valueHome = DkmPointerValueHome.Create(address);
}
}
catch
{
}
DkmEvaluationResult result;
DkmDataItem dataItem = null;
if (item.ShouldForceDefaultVisualizer && !string.IsNullOrEmpty(fullName))
{
using (DkmLanguageExpression languageExpression = DkmLanguageExpression.Create(visualizedExpression.InspectionContext.Language, DkmEvaluationFlags.TreatAsExpression, fullName, null))
{
visualizedExpression.EvaluateExpressionCallback(visualizedExpression.InspectionContext, languageExpression, visualizedExpression.StackFrame, out result);
}
if (result is DkmSuccessEvaluationResult successResult)
{
dataItem = new PassThroughVisualizer(successResult);
result = DkmSuccessEvaluationResult.Create(
successResult.InspectionContext,
successResult.StackFrame,
item.Name, // Name - Left column
successResult.FullName,
successResult.Flags,
successResult.Value, // Value - Middle column
successResult.EditableValue,
successResult.Type, // Type - Right column
category,
successResult.Access,
successResult.StorageType,
successResult.TypeModifierFlags,
successResult.Address,
successResult.CustomUIVisualizers,
successResult.ExternalModules,
successResult.RefreshButtonText,
dataItem);
}
}
else
{
result = DkmSuccessEvaluationResult.Create(
visualizedExpression.InspectionContext,
visualizedExpression.StackFrame,
item.Name, // Name - Left column
fullName, // FullName - What is being copied when "Add to watch"
DkmEvaluationResultFlags.ReadOnly | (item.IsExpandable ? DkmEvaluationResultFlags.Expandable : DkmEvaluationResultFlags.None),
item.ValueString, // Value - Middle column
"",
item.Type ?? "", // Type - Right column
category,
DkmEvaluationResultAccessType.None,
DkmEvaluationResultStorageType.None,
DkmEvaluationResultTypeModifierFlags.None,
null,
VSUIVisualizerService.GetUIVisualizers(item),
null,
null);
dataItem = new VSCustomVisualizerEvaluator(result, item);
}
items[i] = DkmChildVisualizedExpression.Create(
visualizedExpression.InspectionContext,
visualizedExpression.VisualizerId,
visualizedExpression.SourceId,
visualizedExpression.StackFrame,
valueHome,
result,
visualizedExpression,
(uint)(startIndex + i),
dataItem);
}
}
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 static DkmLanguageExpression CppExpression(string expression)
{
return(DkmLanguageExpression.Create(CppLanguage, DkmEvaluationFlags.None, expression, null));
}
