internal abstract CompileResult CompileExpression( InspectionContext inspectionContext, string expr, DkmEvaluationFlags compilationFlags, DiagnosticBag diagnostics, out ResultProperties resultProperties, CompilationTestData testData);
internal DkmInspectionContext(IDkmClrFormatter formatter, DkmEvaluationFlags evaluationFlags, uint radix, DkmRuntimeInstance runtimeInstance = null) { _formatter = formatter; this.EvaluationFlags = evaluationFlags; this.Radix = radix; this.RuntimeInstance = runtimeInstance ?? DkmClrRuntimeInstance.DefaultRuntime; }
internal DkmInspectionContext CreateDkmInspectionContext( DkmEvaluationFlags flags = DkmEvaluationFlags.None, uint radix = 10, DkmRuntimeInstance runtimeInstance = null) { return(CreateDkmInspectionContext(_formatter, flags, radix, runtimeInstance)); }
internal DkmInspectionContext(DkmInspectionSession inspectionSession, DkmEvaluationFlags evaluationFlags, uint radix, DkmRuntimeInstance runtimeInstance) { this.InspectionSession = inspectionSession; this.EvaluationFlags = evaluationFlags; this.Radix = radix; this.RuntimeInstance = runtimeInstance ?? DkmClrRuntimeInstance.DefaultRuntime; }
internal abstract CompileResult CompileExpression( InspectionContext inspectionContext, string expr, DkmEvaluationFlags compilationFlags, DiagnosticBag diagnostics, out ResultProperties resultProperties, CompilationTestData testData);
internal DkmInspectionContext(IDkmClrFormatter formatter, DkmEvaluationFlags evaluationFlags, uint radix, DkmRuntimeInstance runtimeInstance = null) { _formatter = formatter; this.EvaluationFlags = evaluationFlags; this.Radix = radix; this.RuntimeInstance = runtimeInstance ?? DkmClrRuntimeInstance.DefaultRuntime; }
internal static CompileResult CompileExpression( this EvaluationContextBase evaluationContext, string expr, DkmEvaluationFlags compilationFlags, ImmutableArray <Alias> aliases, out string error, CompilationTestData testData = null, DiagnosticFormatter formatter = null) { ResultProperties resultProperties; ImmutableArray <AssemblyIdentity> missingAssemblyIdentities; var result = evaluationContext.CompileExpression( expr, compilationFlags, aliases, formatter ?? DebuggerDiagnosticFormatter.Instance, out resultProperties, out error, out missingAssemblyIdentities, EnsureEnglishUICulture.PreferredOrNull, testData); Assert.Empty(missingAssemblyIdentities); return(result); }
/// <summary> /// Compile C# expression and emit assembly with evaluation method. /// </summary> /// <returns> /// Result containing generated assembly, type and method names, and any format specifiers. /// </returns> internal CompileResult CompileExpression( InspectionContext inspectionContext, string expr, DkmEvaluationFlags compilationFlags, DiagnosticFormatter formatter, out ResultProperties resultProperties, out string error, out ImmutableArray<AssemblyIdentity> missingAssemblyIdentities, CultureInfo preferredUICulture, CompilationTestData testData) { var diagnostics = DiagnosticBag.GetInstance(); var result = this.CompileExpression(inspectionContext, expr, compilationFlags, diagnostics, out resultProperties, testData); if (diagnostics.HasAnyErrors()) { bool useReferencedModulesOnly; error = GetErrorMessageAndMissingAssemblyIdentities(diagnostics, formatter, preferredUICulture, out useReferencedModulesOnly, out missingAssemblyIdentities); } else { error = null; missingAssemblyIdentities = ImmutableArray<AssemblyIdentity>.Empty; } diagnostics.Free(); return result; }
internal static CompileResult CompileExpression( this EvaluationContextBase evaluationContext, string expr, DkmEvaluationFlags compilationFlags, ImmutableArray <Alias> aliases, DiagnosticFormatter formatter, out ResultProperties resultProperties, out string error, out ImmutableArray <AssemblyIdentity> missingAssemblyIdentities, CultureInfo preferredUICulture, CompilationTestData testData) { var diagnostics = DiagnosticBag.GetInstance(); var result = evaluationContext.CompileExpression(expr, compilationFlags, aliases, diagnostics, out resultProperties, testData); if (diagnostics.HasAnyErrors()) { bool useReferencedModulesOnly; error = evaluationContext.GetErrorMessageAndMissingAssemblyIdentities(diagnostics, formatter, preferredUICulture, EvaluationContextBase.SystemCoreIdentity, out useReferencedModulesOnly, out missingAssemblyIdentities); } else { error = null; missingAssemblyIdentities = ImmutableArray <AssemblyIdentity> .Empty; } diagnostics.Free(); return(result); }
internal DkmInspectionContext(DkmInspectionSession inspectionSession, DkmEvaluationFlags evaluationFlags, uint radix, DkmRuntimeInstance runtimeInstance) { this.InspectionSession = inspectionSession; this.EvaluationFlags = evaluationFlags; this.Radix = radix; this.RuntimeInstance = runtimeInstance ?? DkmClrRuntimeInstance.DefaultRuntime; }
internal abstract CompileResult CompileExpression( string expr, DkmEvaluationFlags compilationFlags, ImmutableArray<Alias> aliases, DiagnosticBag diagnostics, out ResultProperties resultProperties, CompilationTestData testData);
internal abstract CompileResult CompileExpression( string expr, DkmEvaluationFlags compilationFlags, ImmutableArray <Alias> aliases, DiagnosticBag diagnostics, out ResultProperties resultProperties, CompilationTestData testData);
public static DkmSuccessEvaluationResult EvaluateSuccess(DkmVisualizedExpression expr, DkmEvaluationFlags flags, string text, DkmDataItem data) { DkmEvaluationResult result = Evaluate(expr, flags, text, data); if (result.TagValue != DkmEvaluationResult.Tag.SuccessResult) throw new EvaluationException(result); return (DkmSuccessEvaluationResult)result; }
internal static DkmInspectionContext CreateDkmInspectionContext( DkmEvaluationFlags evalFlags ) { var inspectionSession = CreateDkmInspectionSession(); return(CreateDkmInspectionContext(inspectionSession, evalFlags, radix: 10)); }
internal static DkmInspectionContext CreateDkmInspectionContext( IDkmClrFormatter formatter, DkmEvaluationFlags flags, uint radix, DkmRuntimeInstance runtimeInstance = null) { return(new DkmInspectionContext(formatter, flags, radix, runtimeInstance)); }
internal static DkmInspectionContext CreateDkmInspectionContext( DkmInspectionSession inspectionSession, DkmEvaluationFlags flags, uint radix, DkmRuntimeInstance runtimeInstance = null) { return(new DkmInspectionContext(inspectionSession, flags, radix, runtimeInstance)); }
internal override CompileResult CompileExpression( string expr, DkmEvaluationFlags compilationFlags, ImmutableArray <Alias> aliases, DiagnosticBag diagnostics, out ResultProperties resultProperties, Microsoft.CodeAnalysis.CodeGen.CompilationTestData testData) { ReadOnlyCollection <string> formatSpecifiers; var syntax = Parse(expr, (compilationFlags & DkmEvaluationFlags.TreatAsExpression) != 0, diagnostics, out formatSpecifiers); if (syntax == null) { resultProperties = default(ResultProperties); return(null); } var context = this.CreateCompilationContext(); var moduleBuilder = context.CompileExpression(syntax, TypeName, MethodName, aliases, testData, diagnostics, out var synthesizedMethod); if (moduleBuilder == null) { resultProperties = default(ResultProperties); return(null); } using (var stream = new MemoryStream()) { Cci.PeWriter.WritePeToStream( new EmitContext(moduleBuilder, null, diagnostics, metadataOnly: false, includePrivateMembers: true), context.MessageProvider, () => stream, getPortablePdbStreamOpt: null, nativePdbWriterOpt: null, pdbPathOpt: null, metadataOnly: false, isDeterministic: false, emitTestCoverageData: false, privateKeyOpt: null, cancellationToken: default(CancellationToken)); if (diagnostics.HasAnyErrors()) { resultProperties = default(ResultProperties); return(null); } Debug.Assert(synthesizedMethod.ContainingType.MetadataName == TypeName); Debug.Assert(synthesizedMethod.MetadataName == MethodName); resultProperties = synthesizedMethod.ResultProperties; return(new CSharpCompileResult( stream.ToArray(), synthesizedMethod, formatSpecifiers: formatSpecifiers)); } }
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); } }
/// <summary> /// Compile C# expression and emit assembly with evaluation method. /// </summary> /// <returns> /// Result containing generated assembly, type and method names, and any format specifiers. /// </returns> internal abstract CompileResult CompileExpression( InspectionContext inspectionContext, string expr, DkmEvaluationFlags compilationFlags, DiagnosticFormatter formatter, out ResultProperties resultProperties, out string error, out ImmutableArray <AssemblyIdentity> missingAssemblyIdentities, CultureInfo preferredUICulture, CompilationTestData testData);
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; } }
/// <summary> /// Compile C# expression and emit assembly with evaluation method. /// </summary> /// <returns> /// Result containing generated assembly, type and method names, and any format specifiers. /// </returns> internal abstract CompileResult CompileExpression( InspectionContext inspectionContext, string expr, DkmEvaluationFlags compilationFlags, DiagnosticFormatter formatter, out ResultProperties resultProperties, out string error, out ImmutableArray<AssemblyIdentity> missingAssemblyIdentities, CultureInfo preferredUICulture, CompilationTestData testData);
internal override CompileResult CompileExpression( string expr, DkmEvaluationFlags compilationFlags, ImmutableArray <Alias> aliases, DiagnosticBag diagnostics, out ResultProperties resultProperties, Microsoft.CodeAnalysis.CodeGen.CompilationTestData testData) { ReadOnlyCollection <string> formatSpecifiers; var syntax = Parse(expr, (compilationFlags & DkmEvaluationFlags.TreatAsExpression) != 0, diagnostics, out formatSpecifiers); if (syntax == null) { resultProperties = default(ResultProperties); return(null); } var context = this.CreateCompilationContext(syntax); ResultProperties properties; var moduleBuilder = context.CompileExpression(TypeName, MethodName, aliases, testData, diagnostics, out properties); if (moduleBuilder == null) { resultProperties = default(ResultProperties); return(null); } using (var stream = new MemoryStream()) { Cci.PeWriter.WritePeToStream( new EmitContext((Cci.IModule)moduleBuilder, null, diagnostics), context.MessageProvider, () => stream, getPortablePdbStreamOpt: null, nativePdbWriterOpt: null, pdbPathOpt: null, allowMissingMethodBodies: false, deterministic: false, cancellationToken: default(CancellationToken)); if (diagnostics.HasAnyErrors()) { resultProperties = default(ResultProperties); return(null); } resultProperties = properties; return(new CSharpCompileResult( stream.ToArray(), GetSynthesizedMethod(moduleBuilder), formatSpecifiers: formatSpecifiers)); } }
private string FormatString(string s, DkmEvaluationFlags flags) { if (flags.HasFlag(DkmEvaluationFlags.NoQuotes)) { // No quotes - return the raw string. // If X# handled escaping aside from quotes, we would still want to do escaping. return(s); } else { // Escape special characters in the string and wrap in single quotes. s = s.Replace("\"", "\"\""); return("\"" + s + "\""); } }
public static DkmInspectionContext Create( DkmInspectionSession InspectionSession, DkmRuntimeInstance RuntimeInstance, DkmThread Thread, uint Timeout, DkmEvaluationFlags EvaluationFlags, DkmFuncEvalFlags FuncEvalFlags, uint Radix, DkmLanguage Language, DkmRawReturnValue ReturnValue, DkmCompiledVisualizationData AdditionalVisualizationData, DkmCompiledVisualizationDataPriority AdditionalVisualizationDataPriority, ReadOnlyCollection<DkmRawReturnValueContainer> ReturnValues) { return new DkmInspectionContext(InspectionSession, EvaluationFlags, Radix, RuntimeInstance); }
internal static DkmInspectionContext With(this DkmInspectionContext inspectionContext, DkmEvaluationFlags flags) { return DkmInspectionContext.Create( inspectionContext.InspectionSession, inspectionContext.RuntimeInstance, inspectionContext.Thread, inspectionContext.Timeout, inspectionContext.EvaluationFlags | flags, inspectionContext.FuncEvalFlags, inspectionContext.Radix, inspectionContext.Language, inspectionContext.ReturnValue, inspectionContext.AdditionalVisualizationData, inspectionContext.AdditionalVisualizationDataPriority, inspectionContext.ReturnValues); }
public static DkmInspectionContext Create( DkmInspectionSession InspectionSession, DkmRuntimeInstance RuntimeInstance, DkmThread Thread, uint Timeout, DkmEvaluationFlags EvaluationFlags, DkmFuncEvalFlags FuncEvalFlags, uint Radix, DkmLanguage Language, DkmRawReturnValue ReturnValue, DkmCompiledVisualizationData AdditionalVisualizationData, DkmCompiledVisualizationDataPriority AdditionalVisualizationDataPriority, ReadOnlyCollection <DkmRawReturnValueContainer> ReturnValues) { return(new DkmInspectionContext(InspectionSession, EvaluationFlags, Radix, RuntimeInstance)); }
internal static DkmInspectionContext With( this DkmInspectionContext inspectionContext, DkmEvaluationFlags flags ) { return(DkmInspectionContext.Create( inspectionContext.InspectionSession, inspectionContext.RuntimeInstance, inspectionContext.Thread, inspectionContext.Timeout, inspectionContext.EvaluationFlags | flags, inspectionContext.FuncEvalFlags, inspectionContext.Radix, inspectionContext.Language, inspectionContext.ReturnValue, inspectionContext.AdditionalVisualizationData, inspectionContext.AdditionalVisualizationDataPriority, inspectionContext.ReturnValues )); }
internal EvalResultDataItem CreateDataItem( DkmInspectionContext inspectionContext, string name, Type typeDeclaringMember, Type declaredType, DkmClrValue value, EvalResultDataItem parent, ExpansionFlags expansionFlags, bool childShouldParenthesize, string fullName, ReadOnlyCollection<string> formatSpecifiers, DkmEvaluationResultCategory category, DkmEvaluationResultFlags flags, DkmEvaluationFlags evalFlags) { if ((evalFlags & DkmEvaluationFlags.ShowValueRaw) != 0) { formatSpecifiers = Formatter.AddFormatSpecifier(formatSpecifiers, "raw"); } Expansion expansion; // If the declared type is Nullable<T>, the value should // have no expansion if null, or be expanded as a T. var lmrNullableTypeArg = declaredType.GetNullableTypeArgument(); if (lmrNullableTypeArg != null && !value.HasExceptionThrown(parent)) { Debug.Assert(value.Type.GetProxyType() == null); var nullableValue = value.GetNullableValue(); if (nullableValue == null) { Debug.Assert(declaredType.Equals(value.Type.GetLmrType())); // No expansion of "null". expansion = null; } else { value = nullableValue; Debug.Assert(lmrNullableTypeArg.Equals(value.Type.GetLmrType())); // If this is not the case, add a test for includeRuntimeTypeIfNecessary. expansion = this.GetTypeExpansion(inspectionContext, lmrNullableTypeArg, value, ExpansionFlags.IncludeResultsView); } } else if (value.IsError() || (inspectionContext.EvaluationFlags & DkmEvaluationFlags.NoExpansion) != 0) { expansion = null; } else { expansion = DebuggerTypeProxyExpansion.CreateExpansion( this, inspectionContext, name, typeDeclaringMember, declaredType, value, childShouldParenthesize, fullName, flags.Includes(DkmEvaluationResultFlags.ExceptionThrown) ? null : fullName, formatSpecifiers, flags, this.Formatter.GetEditableValue(value)); if (expansion == null) { var expansionType = value.HasExceptionThrown(parent) ? value.Type.GetLmrType() : declaredType; expansion = this.GetTypeExpansion(inspectionContext, expansionType, value, expansionFlags); } } return new EvalResultDataItem( name, typeDeclaringMember, declaredType, value, expansion, childShouldParenthesize, fullName, flags.Includes(DkmEvaluationResultFlags.ExceptionThrown) ? null : fullName, formatSpecifiers, category, flags, this.Formatter.GetEditableValue(value)); }
internal EvalResultDataItem CreateDataItem( DkmInspectionContext inspectionContext, string name, Type typeDeclaringMember, Type declaredType, DkmClrValue value, EvalResultDataItem parent, ExpansionFlags expansionFlags, bool childShouldParenthesize, string fullName, ReadOnlyCollection <string> formatSpecifiers, DkmEvaluationResultCategory category, DkmEvaluationResultFlags flags, DkmEvaluationFlags evalFlags) { if ((evalFlags & DkmEvaluationFlags.ShowValueRaw) != 0) { formatSpecifiers = Formatter.AddFormatSpecifier(formatSpecifiers, "raw"); } Expansion expansion; // If the declared type is Nullable<T>, the value should // have no expansion if null, or be expanded as a T. var lmrNullableTypeArg = declaredType.GetNullableTypeArgument(); if (lmrNullableTypeArg != null && !value.HasExceptionThrown(parent)) { Debug.Assert(value.Type.GetProxyType() == null); var nullableValue = value.GetNullableValue(inspectionContext); if (nullableValue == null) { Debug.Assert(declaredType.Equals(value.Type.GetLmrType())); // No expansion of "null". expansion = null; } else { value = nullableValue; Debug.Assert(lmrNullableTypeArg.Equals(value.Type.GetLmrType())); // If this is not the case, add a test for includeRuntimeTypeIfNecessary. expansion = this.GetTypeExpansion(inspectionContext, lmrNullableTypeArg, value, ExpansionFlags.IncludeResultsView); } } else if (value.IsError() || (inspectionContext.EvaluationFlags & DkmEvaluationFlags.NoExpansion) != 0) { expansion = null; } else { expansion = DebuggerTypeProxyExpansion.CreateExpansion( this, inspectionContext, name, typeDeclaringMember, declaredType, value, childShouldParenthesize, fullName, flags.Includes(DkmEvaluationResultFlags.ExceptionThrown) ? null : fullName, formatSpecifiers, flags, this.Formatter.GetEditableValue(value, inspectionContext)); if (expansion == null) { var expansionType = value.HasExceptionThrown(parent) ? value.Type.GetLmrType() : declaredType; expansion = this.GetTypeExpansion(inspectionContext, expansionType, value, expansionFlags); } } return(new EvalResultDataItem( ExpansionKind.Default, name, typeDeclaringMember, declaredType, parent: parent, value: value, displayValue: null, expansion: expansion, childShouldParenthesize: childShouldParenthesize, fullName: fullName, childFullNamePrefixOpt: flags.Includes(DkmEvaluationResultFlags.ExceptionThrown) ? null : fullName, formatSpecifiers: formatSpecifiers, category: category, flags: flags, editableValue: this.Formatter.GetEditableValue(value, inspectionContext), inspectionContext: inspectionContext)); }
internal override CompileResult CompileExpression( InspectionContext inspectionContext, string expr, DkmEvaluationFlags compilationFlags, DiagnosticFormatter formatter, out ResultProperties resultProperties, out string error, out ImmutableArray <AssemblyIdentity> missingAssemblyIdentities, System.Globalization.CultureInfo preferredUICulture, Microsoft.CodeAnalysis.CodeGen.CompilationTestData testData) { resultProperties = default(ResultProperties); var diagnostics = DiagnosticBag.GetInstance(); try { ReadOnlyCollection <string> formatSpecifiers; var syntax = Parse(expr, (compilationFlags & DkmEvaluationFlags.TreatAsExpression) != 0, diagnostics, out formatSpecifiers); if (syntax == null) { error = GetErrorMessageAndMissingAssemblyIdentities(diagnostics, formatter, preferredUICulture, out missingAssemblyIdentities); return(default(CompileResult)); } var context = this.CreateCompilationContext(syntax); ResultProperties properties; var moduleBuilder = context.CompileExpression(inspectionContext, TypeName, MethodName, testData, diagnostics, out properties); if (moduleBuilder == null) { error = GetErrorMessageAndMissingAssemblyIdentities(diagnostics, formatter, preferredUICulture, out missingAssemblyIdentities); return(default(CompileResult)); } using (var stream = new MemoryStream()) { Cci.PeWriter.WritePeToStream( new EmitContext((Cci.IModule)moduleBuilder, null, diagnostics), context.MessageProvider, stream, nativePdbWriterOpt: null, allowMissingMethodBodies: false, deterministic: false, cancellationToken: default(CancellationToken)); if (diagnostics.HasAnyErrors()) { error = GetErrorMessageAndMissingAssemblyIdentities(diagnostics, formatter, preferredUICulture, out missingAssemblyIdentities); return(default(CompileResult)); } resultProperties = properties; error = null; missingAssemblyIdentities = ImmutableArray <AssemblyIdentity> .Empty; return(new CompileResult( stream.ToArray(), typeName: TypeName, methodName: MethodName, formatSpecifiers: formatSpecifiers)); } } finally { diagnostics.Free(); } }
internal override CompileResult CompileExpression( InspectionContext inspectionContext, string expr, DkmEvaluationFlags compilationFlags, DiagnosticFormatter formatter, out ResultProperties resultProperties, out string error, out ImmutableArray<AssemblyIdentity> missingAssemblyIdentities, System.Globalization.CultureInfo preferredUICulture, Microsoft.CodeAnalysis.CodeGen.CompilationTestData testData) { resultProperties = default(ResultProperties); var diagnostics = DiagnosticBag.GetInstance(); try { ReadOnlyCollection<string> formatSpecifiers; var syntax = Parse(expr, (compilationFlags & DkmEvaluationFlags.TreatAsExpression) != 0, diagnostics, out formatSpecifiers); if (syntax == null) { error = GetErrorMessageAndMissingAssemblyIdentities(diagnostics, formatter, preferredUICulture, out missingAssemblyIdentities); return default(CompileResult); } var context = this.CreateCompilationContext(syntax); ResultProperties properties; var moduleBuilder = context.CompileExpression(inspectionContext, TypeName, MethodName, testData, diagnostics, out properties); if (moduleBuilder == null) { error = GetErrorMessageAndMissingAssemblyIdentities(diagnostics, formatter, preferredUICulture, out missingAssemblyIdentities); return default(CompileResult); } using (var stream = new MemoryStream()) { Cci.PeWriter.WritePeToStream( new EmitContext((Cci.IModule)moduleBuilder, null, diagnostics), context.MessageProvider, stream, nativePdbWriterOpt: null, allowMissingMethodBodies: false, deterministic: false, cancellationToken: default(CancellationToken)); if (diagnostics.HasAnyErrors()) { error = GetErrorMessageAndMissingAssemblyIdentities(diagnostics, formatter, preferredUICulture, out missingAssemblyIdentities); return default(CompileResult); } resultProperties = properties; error = null; missingAssemblyIdentities = ImmutableArray<AssemblyIdentity>.Empty; return new CompileResult( stream.ToArray(), typeName: TypeName, methodName: MethodName, formatSpecifiers: formatSpecifiers); } } finally { diagnostics.Free(); } }
internal DkmInspectionContext CreateDkmInspectionContext(DkmEvaluationFlags flags = DkmEvaluationFlags.None, uint radix = 10) { return(CreateDkmInspectionContext(_formatter, flags, radix)); }
internal EvalResult CreateDataItem( DkmInspectionContext inspectionContext, string name, TypeAndCustomInfo typeDeclaringMemberAndInfo, TypeAndCustomInfo declaredTypeAndInfo, DkmClrValue value, bool useDebuggerDisplay, ExpansionFlags expansionFlags, bool childShouldParenthesize, string fullName, ReadOnlyCollection <string> formatSpecifiers, DkmEvaluationResultCategory category, DkmEvaluationResultFlags flags, DkmEvaluationFlags evalFlags) { if ((evalFlags & DkmEvaluationFlags.ShowValueRaw) != 0) { formatSpecifiers = Formatter.AddFormatSpecifier(formatSpecifiers, "raw"); } Expansion expansion; // If the declared type is Nullable<T>, the value should // have no expansion if null, or be expanded as a T. var declaredType = declaredTypeAndInfo.Type; var lmrNullableTypeArg = declaredType.GetNullableTypeArgument(); if (lmrNullableTypeArg != null && !value.HasExceptionThrown()) { Debug.Assert(value.Type.GetProxyType() == null); DkmClrValue nullableValue; if (value.IsError()) { expansion = null; } else if ((nullableValue = value.GetNullableValue(lmrNullableTypeArg, inspectionContext)) == null) { Debug.Assert(declaredType.Equals(value.Type.GetLmrType())); // No expansion of "null". expansion = null; } else { value = nullableValue; Debug.Assert(lmrNullableTypeArg.Equals(value.Type.GetLmrType())); // If this is not the case, add a test for includeRuntimeTypeIfNecessary. // CONSIDER: The DynamicAttribute for the type argument should just be Skip(1) of the original flag array. expansion = this.GetTypeExpansion(inspectionContext, new TypeAndCustomInfo(DkmClrType.Create(declaredTypeAndInfo.ClrType.AppDomain, lmrNullableTypeArg)), value, ExpansionFlags.IncludeResultsView); } } else if (value.IsError() || (inspectionContext.EvaluationFlags & DkmEvaluationFlags.NoExpansion) != 0) { expansion = null; } else { expansion = DebuggerTypeProxyExpansion.CreateExpansion( this, inspectionContext, name, typeDeclaringMemberAndInfo, declaredTypeAndInfo, value, childShouldParenthesize, fullName, flags.Includes(DkmEvaluationResultFlags.ExceptionThrown) ? null : fullName, formatSpecifiers, flags, Formatter2.GetEditableValueString(value, inspectionContext, declaredTypeAndInfo.Info)); if (expansion == null) { expansion = value.HasExceptionThrown() ? this.GetTypeExpansion(inspectionContext, new TypeAndCustomInfo(value.Type), value, expansionFlags) : this.GetTypeExpansion(inspectionContext, declaredTypeAndInfo, value, expansionFlags); } } return(new EvalResult( ExpansionKind.Default, name, typeDeclaringMemberAndInfo, declaredTypeAndInfo, useDebuggerDisplay: useDebuggerDisplay, value: value, displayValue: null, expansion: expansion, childShouldParenthesize: childShouldParenthesize, fullName: fullName, childFullNamePrefixOpt: flags.Includes(DkmEvaluationResultFlags.ExceptionThrown) ? null : fullName, formatSpecifiers: formatSpecifiers, category: category, flags: flags, editableValue: Formatter2.GetEditableValueString(value, inspectionContext, declaredTypeAndInfo.Info), inspectionContext: inspectionContext)); }
internal static string TryEvaluateStringExpression(string expression, DkmInspectionSession inspectionSession, DkmThread thread, DkmStackWalkFrame input, DkmEvaluationFlags flags) { return(ExecuteExpression(expression + ",sb", inspectionSession, thread, input, flags, false, out _)); }
internal DkmInspectionContext(IDkmClrFormatter formatter, DkmEvaluationFlags evaluationFlags, uint radix) { _formatter = formatter; this.EvaluationFlags = evaluationFlags; this.Radix = radix; }
internal static DkmInspectionContext CreateDkmInspectionContext(IDkmClrFormatter formatter, DkmEvaluationFlags flags, uint radix) { return(new DkmInspectionContext(formatter, flags, radix)); }
internal static ulong?TryEvaluateAddressExpression(string expression, DkmInspectionSession inspectionSession, DkmThread thread, DkmStackWalkFrame input, DkmEvaluationFlags flags) { if (ExecuteExpression(expression, inspectionSession, thread, input, flags, true, out ulong address) != null) { return(address); } return(null); }
internal DkmInspectionContext(IDkmClrFormatter formatter, DkmEvaluationFlags evaluationFlags, uint radix) { _formatter = formatter; this.EvaluationFlags = evaluationFlags; this.Radix = radix; }
internal static long?TryEvaluateNumberExpression(string expression, DkmInspectionSession inspectionSession, DkmThread thread, DkmStackWalkFrame input, DkmEvaluationFlags flags) { string result = ExecuteExpression(expression, inspectionSession, thread, input, flags, true, out _); if (result == null) { return(null); } if (long.TryParse(result, out long value)) { return(value); } return(null); }
internal override CompileResult CompileExpression( InspectionContext inspectionContext, string expr, DkmEvaluationFlags compilationFlags, DiagnosticBag diagnostics, out ResultProperties resultProperties, Microsoft.CodeAnalysis.CodeGen.CompilationTestData testData) { ReadOnlyCollection<string> formatSpecifiers; var syntax = Parse(expr, (compilationFlags & DkmEvaluationFlags.TreatAsExpression) != 0, diagnostics, out formatSpecifiers); if (syntax == null) { resultProperties = default(ResultProperties); return null; } var context = this.CreateCompilationContext(syntax); ResultProperties properties; var moduleBuilder = context.CompileExpression(inspectionContext, TypeName, MethodName, testData, diagnostics, out properties); if (moduleBuilder == null) { resultProperties = default(ResultProperties); return null; } using (var stream = new MemoryStream()) { Cci.PeWriter.WritePeToStream( new EmitContext((Cci.IModule)moduleBuilder, null, diagnostics), context.MessageProvider, () => stream, nativePdbWriterOpt: null, pdbPathOpt: null, allowMissingMethodBodies: false, deterministic: false, cancellationToken: default(CancellationToken)); if (diagnostics.HasAnyErrors()) { resultProperties = default(ResultProperties); return null; } resultProperties = properties; return new CSharpCompileResult( stream.ToArray(), GetSynthesizedMethod(moduleBuilder), formatSpecifiers: formatSpecifiers); } }
private string FormatString(string s, DkmEvaluationFlags flags) { if (flags.HasFlag(DkmEvaluationFlags.NoQuotes)) { // No quotes - return the raw string. // If Iris handled escaping aside from quotes, we would still want to do escaping. return s; } else { // Escape special characters in the string and wrap in single quotes. s = s.Replace("'", "''"); return "'" + s + "'"; } }
internal EvalResultDataItem CreateDataItem( DkmInspectionContext inspectionContext, string name, TypeAndCustomInfo typeDeclaringMemberAndInfo, TypeAndCustomInfo declaredTypeAndInfo, DkmClrValue value, EvalResultDataItem parent, ExpansionFlags expansionFlags, bool childShouldParenthesize, string fullName, ReadOnlyCollection<string> formatSpecifiers, DkmEvaluationResultCategory category, DkmEvaluationResultFlags flags, DkmEvaluationFlags evalFlags) { if ((evalFlags & DkmEvaluationFlags.ShowValueRaw) != 0) { formatSpecifiers = Formatter.AddFormatSpecifier(formatSpecifiers, "raw"); } Expansion expansion; // If the declared type is Nullable<T>, the value should // have no expansion if null, or be expanded as a T. var declaredType = declaredTypeAndInfo.Type; var lmrNullableTypeArg = declaredType.GetNullableTypeArgument(); if (lmrNullableTypeArg != null && !value.HasExceptionThrown()) { Debug.Assert(value.Type.GetProxyType() == null); DkmClrValue nullableValue; if (value.IsError()) { expansion = null; } else if ((nullableValue = value.GetNullableValue(inspectionContext)) == null) { Debug.Assert(declaredType.Equals(value.Type.GetLmrType())); // No expansion of "null". expansion = null; } else { value = nullableValue; Debug.Assert(lmrNullableTypeArg.Equals(value.Type.GetLmrType())); // If this is not the case, add a test for includeRuntimeTypeIfNecessary. // CONSIDER: The DynamicAttribute for the type argument should just be Skip(1) of the original flag array. expansion = this.GetTypeExpansion(inspectionContext, new TypeAndCustomInfo(lmrNullableTypeArg), value, ExpansionFlags.IncludeResultsView); } } else if (value.IsError() || (inspectionContext.EvaluationFlags & DkmEvaluationFlags.NoExpansion) != 0) { expansion = null; } else { expansion = DebuggerTypeProxyExpansion.CreateExpansion( this, inspectionContext, name, typeDeclaringMemberAndInfo, declaredTypeAndInfo, value, childShouldParenthesize, fullName, flags.Includes(DkmEvaluationResultFlags.ExceptionThrown) ? null : fullName, formatSpecifiers, flags, this.Formatter.GetEditableValue(value, inspectionContext)); if (expansion == null) { expansion = value.HasExceptionThrown() ? this.GetTypeExpansion(inspectionContext, new TypeAndCustomInfo(value.Type), value, expansionFlags) : this.GetTypeExpansion(inspectionContext, declaredTypeAndInfo, value, expansionFlags); } } return new EvalResultDataItem( ExpansionKind.Default, name, typeDeclaringMemberAndInfo, declaredTypeAndInfo, parent: parent, value: value, displayValue: null, expansion: expansion, childShouldParenthesize: childShouldParenthesize, fullName: fullName, childFullNamePrefixOpt: flags.Includes(DkmEvaluationResultFlags.ExceptionThrown) ? null : fullName, formatSpecifiers: formatSpecifiers, category: category, flags: flags, editableValue: this.Formatter.GetEditableValue(value, inspectionContext), inspectionContext: inspectionContext); }
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); DkmInspectionContext inspectionContext; LuaWorkerConnectionWrapper workerConnectionWrapper = inspectionSession.Process.GetDataItem <LuaWorkerConnectionWrapper>(); if (workerConnectionWrapper != null) { inspectionContext = workerConnectionWrapper.CreateInspectionSession(inspectionSession, input.RuntimeInstance, thread, flags, language); } else { inspectionContext = DkmInspectionContext.Create(inspectionSession, input.RuntimeInstance, thread, 200, flags, DkmFuncEvalFlags.None, 10, language, null); } 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); } }
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); DkmInspectionContext inspectionContext; LuaWorkerConnectionWrapper workerConnectionWrapper = inspectionSession.Process.GetDataItem <LuaWorkerConnectionWrapper>(); if (workerConnectionWrapper != null) { inspectionContext = workerConnectionWrapper.CreateInspectionSession(inspectionSession, runtimeInstance, thread, flags, language); } else { inspectionContext = DkmInspectionContext.Create(inspectionSession, runtimeInstance, thread, 200, flags, DkmFuncEvalFlags.None, 10, language, null); } 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 DkmSuccessEvaluationResult EvaluateSuccess(DkmVisualizedExpression expr, DkmEvaluationFlags flags, string text, DkmDataItem data) { DkmEvaluationResult result = Evaluate(expr, flags, text, data); if (result.TagValue != DkmEvaluationResult.Tag.SuccessResult) { throw new EvaluationException(result); } return((DkmSuccessEvaluationResult)result); }