public override bool WriteName(ITextColorWriter writer, DbgExceptionDefinition definition)
{
var fullName = definition.Id.Name;
if (!string.IsNullOrEmpty(fullName))
{
var nsParts = fullName.Split(nsSeps);
int pos = 0;
var partColor = BoxedTextColor.Namespace;
for (int i = 0; i < nsParts.Length - 1; i++)
{
var ns = nsParts[i];
var sep = fullName[pos + ns.Length];
if (sep == '+')
{
partColor = BoxedTextColor.Type;
}
writer.Write(partColor, ns);
writer.Write(BoxedTextColor.Operator, sep.ToString());
pos += ns.Length + 1;
}
writer.Write(BoxedTextColor.Type, nsParts[nsParts.Length - 1]);
}
return(true);
}
public override void WriteName(IDbgTextWriter writer, DbgExceptionId id, bool includeDescription)
{
if (!exceptionSettingsService.Value.TryGetDefinition(id, out var def))
{
def = new DbgExceptionDefinition(id, DbgExceptionDefinitionFlags.None, description: null);
}
WriteName(writer, def, includeDescription);
}
static bool Compare(DbgExceptionSettings settings, DbgExceptionDefinition def)
{
if (settings.Conditions.Count != 0)
{
return(false);
}
return(settings.Flags == def.Flags);
}
void WriteDescription(IDbgTextWriter writer, DbgExceptionDefinition definition)
{
if (definition.Description is null)
{
return;
}
writer.Write(DbgTextColor.Comment, "(");
writer.Write(DbgTextColor.Comment, definition.Description);
writer.Write(DbgTextColor.Comment, ")");
}
void WriteDescription(ITextColorWriter writer, DbgExceptionDefinition definition)
{
if (definition.Description == null)
{
return;
}
writer.Write(BoxedTextColor.Comment, "(");
writer.Write(BoxedTextColor.Comment, definition.Description);
writer.Write(BoxedTextColor.Comment, ")");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="definition">Exception definition</param>
/// <param name="settings">Exception settings</param>
public DbgExceptionSettingsInfo(DbgExceptionDefinition definition, DbgExceptionSettings settings)
{
if (definition.Id.Category is null)
{
throw new ArgumentException();
}
if (settings.Conditions is null)
{
throw new ArgumentException();
}
Definition = definition;
Settings = settings;
}
void WriteNameCore(IDbgTextWriter writer, DbgExceptionDefinition definition)
{
if (!definition.Id.IsDefaultId && toFormatters.TryGetValue(definition.Id.Category, out var formatters))
{
foreach (var formatter in formatters)
{
if (formatter.Value.WriteName(writer, definition))
{
return;
}
}
}
DefaultWriteName(writer, definition);
}
void DefaultWriteName(IDbgTextWriter output, DbgExceptionDefinition definition)
{
switch (definition.Id.Kind)
{
case DbgExceptionIdKind.DefaultId:
if (exceptionSettingsService.Value.TryGetCategoryDefinition(definition.Id.Category, out var categoryDef))
{
output.Write(DbgTextColor.Text, string.Format(dnSpy_Debugger_Resources.AllRemainingExceptionsNotInList, categoryDef.DisplayName));
}
else
{
WriteError(output);
}
break;
case DbgExceptionIdKind.Code:
DbgExceptionCategoryDefinitionFlags flags;
if (exceptionSettingsService.Value.TryGetCategoryDefinition(definition.Id.Category, out categoryDef))
{
flags = categoryDef.Flags;
}
else
{
flags = DbgExceptionCategoryDefinitionFlags.None;
}
if ((flags & DbgExceptionCategoryDefinitionFlags.DecimalCode) == 0)
{
output.Write(DbgTextColor.Number, "0x" + definition.Id.Code.ToString("X8"));
}
else if ((flags & DbgExceptionCategoryDefinitionFlags.UnsignedCode) != 0)
{
output.Write(DbgTextColor.Number, ((uint)definition.Id.Code).ToString());
}
else
{
output.Write(DbgTextColor.Number, definition.Id.Code.ToString());
}
break;
case DbgExceptionIdKind.Name:
output.Write(DbgTextColor.Keyword, definition.Id.Name);
break;
default:
WriteError(output);
break;
}
}
public override bool TryGetDefinition(DbgExceptionId id, out DbgExceptionDefinition definition)
{
if (id.Category is null)
{
throw new ArgumentException();
}
lock (lockObj) {
if (toExceptionInfo.TryGetValue(id, out var info))
{
definition = info.Definition;
return(true);
}
}
definition = default;
return(false);
}
public override void WriteName(IDbgTextWriter writer, DbgExceptionDefinition definition, bool includeDescription)
{
if (writer is null)
{
throw new ArgumentNullException(nameof(writer));
}
if (definition.Id.Category is null)
{
throw new ArgumentException();
}
WriteNameCore(writer, definition);
if (includeDescription && definition.Description is not null)
{
writer.Write(DbgTextColor.Text, " ");
WriteDescription(writer, definition);
}
}
public override void WriteName(ITextColorWriter writer, DbgExceptionDefinition definition, bool includeDescription)
{
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
if (definition.Id.Category == null)
{
throw new ArgumentException();
}
WriteNameCore(writer, definition);
if (includeDescription && definition.Description != null)
{
writer.WriteSpace();
WriteDescription(writer, definition);
}
}
public override void Execute(string context)
{
if (context == null)
{
return;
}
var id = new DbgExceptionId(PredefinedExceptionCategories.DotNet, context);
if (dbgExceptionSettingsService.Value.TryGetSettings(id, out var settings))
{
settings = new DbgExceptionSettings(settings.Flags | DbgExceptionDefinitionFlags.StopFirstChance, settings.Conditions);
dbgExceptionSettingsService.Value.Modify(id, settings);
}
else
{
var def = new DbgExceptionDefinition(id, DbgExceptionDefinitionFlags.StopFirstChance | DbgExceptionDefinitionFlags.StopSecondChance);
settings = new DbgExceptionSettings(def.Flags);
var info = new DbgExceptionSettingsInfo(def, settings);
dbgExceptionSettingsService.Value.Add(info);
}
}
public abstract void WriteName(IDbgTextWriter writer, DbgExceptionDefinition definition, bool includeDescription);
public ExceptionInfo(DbgExceptionDefinition definition, DbgExceptionSettings settings)
{
Definition = definition;
Settings = settings;
}