private void MarkType(TypeDefinition type, Marking mark, List <MemberSetting> settings)
{
bool exclude;
MemberSetting ret = MarkType(type, mark, out exclude);
ret.Parameters = mark.CurrentConfusions;
if (!exclude)
{
List <MemberSetting> memSettings = new List <MemberSetting>();
foreach (TypeDefinition nType in type.NestedTypes)
{
mark.StartLevel();
MarkType(nType, mark, memSettings);
mark.LeaveLevel();
}
foreach (MethodDefinition mtd in type.Methods)
{
mark.StartLevel();
MarkMember(mtd, mark, Target.Methods, memSettings);
mark.LeaveLevel();
}
foreach (FieldDefinition fld in type.Fields)
{
mark.StartLevel();
MarkMember(fld, mark, Target.Fields, memSettings);
mark.LeaveLevel();
}
foreach (PropertyDefinition prop in type.Properties)
{
mark.StartLevel();
MarkMember(prop, mark, Target.Properties, memSettings);
mark.LeaveLevel();
}
foreach (EventDefinition evt in type.Events)
{
mark.StartLevel();
MarkMember(evt, mark, Target.Events, memSettings);
mark.LeaveLevel();
}
ret.Members = memSettings.ToArray();
}
if (!ret.Parameters.IsEmpty() || ret.Members.Length != 0)
{
settings.Add(ret);
}
mark.LeaveLevel();
}
private void MarkModule(ModuleDefinition mod, Marking mark, List <ModuleSetting> settings)
{
bool exclude;
ModuleSetting ret = MarkModule(mod, mark, out exclude);
ret.Parameters = mark.CurrentConfusions;
if (!exclude)
{
List <MemberSetting> typeSettings = new List <MemberSetting>();
foreach (TypeDefinition type in mod.Types)
{
mark.StartLevel();
MarkType(type, mark, typeSettings);
mark.LeaveLevel();
}
ret.Members = typeSettings.ToArray();
}
settings.Add(ret);
mark.LeaveLevel();
}
private void MarkMember(IMemberDefinition mem, Marking mark, Target target, List <MemberSetting> settings)
{
if (target == Target.Methods && (mem as MethodDefinition).SemanticsAttributes != MethodSemanticsAttributes.None)
{
return;
}
bool exclude;
MemberSetting ret = MarkMember(mem, mark, out exclude);
ret.Parameters = mark.CurrentConfusions;
if (!exclude)
{
List <MemberSetting> semSettings = new List <MemberSetting>();
if (target == Target.Properties)
{
PropertyDefinition prop = mem as PropertyDefinition;
List <MethodDefinition> sems = new List <MethodDefinition>();
if (prop.GetMethod != null)
{
sems.Add(prop.GetMethod);
}
if (prop.SetMethod != null)
{
sems.Add(prop.SetMethod);
}
if (prop.HasOtherMethods)
{
sems.AddRange(prop.OtherMethods);
}
foreach (MethodDefinition mtd in sems)
{
mark.StartLevel();
ProcessAttribute(mtd, mark);
semSettings.Add(new MemberSetting(mtd)
{
Parameters = mark.CurrentConfusions, Members = new MemberSetting[0]
});
mark.LeaveLevel();
mark.LeaveLevel();
}
}
else if (target == Target.Events)
{
EventDefinition evt = mem as EventDefinition;
List <MethodDefinition> sems = new List <MethodDefinition>();
if (evt.AddMethod != null)
{
sems.Add(evt.AddMethod);
}
if (evt.RemoveMethod != null)
{
sems.Add(evt.RemoveMethod);
}
if (evt.InvokeMethod != null)
{
sems.Add(evt.InvokeMethod);
}
if (evt.HasOtherMethods)
{
sems.AddRange(evt.OtherMethods);
}
foreach (MethodDefinition mtd in sems)
{
mark.StartLevel();
ProcessAttribute(mtd, mark);
semSettings.Add(new MemberSetting(mtd)
{
Parameters = mark.CurrentConfusions, Members = new MemberSetting[0]
});
mark.LeaveLevel();
mark.LeaveLevel();
}
}
ret.Members = semSettings.ToArray();
}
if (!ret.Parameters.IsEmpty() || ret.Members.Length != 0)
{
settings.Add(ret);
}
mark.LeaveLevel();
}
private bool ProcessAttribute(ICustomAttributeProvider provider, Marking setting)
{
CustomAttribute att = GetAttribute(provider.CustomAttributes, "ConfusingAttribute");
if (att == null)
{
setting.StartLevel();
return(false);
}
CustomAttributeNamedArgument stripArg = att.Properties.FirstOrDefault(arg => arg.Name == "StripAfterObfuscation");
bool strip = true;
if (!stripArg.Equals(default(CustomAttributeNamedArgument)))
{
strip = (bool)stripArg.Argument.Value;
}
if (strip)
{
provider.CustomAttributes.Remove(att);
}
CustomAttributeNamedArgument excludeArg = att.Properties.FirstOrDefault(arg => arg.Name == "Exclude");
bool exclude = false;
if (!excludeArg.Equals(default(CustomAttributeNamedArgument)))
{
exclude = (bool)excludeArg.Argument.Value;
}
if (exclude)
{
setting.CurrentConfusions.Clear();
}
CustomAttributeNamedArgument applyToMembersArg = att.Properties.FirstOrDefault(arg => arg.Name == "ApplyToMembers");
bool applyToMembers = true;
if (!applyToMembersArg.Equals(default(CustomAttributeNamedArgument)))
{
applyToMembers = (bool)applyToMembersArg.Argument.Value;
}
if (applyToMembers)
{
setting.StartLevel();
}
else
{
setting.SkipLevel();
}
try
{
if (!exclude)
{
CustomAttributeNamedArgument featureArg = att.Properties.FirstOrDefault(arg => arg.Name == "Config");
string feature = "all";
if (!featureArg.Equals(default(CustomAttributeNamedArgument)))
{
feature = (string)featureArg.Argument.Value;
}
if (string.Equals(feature, "all", StringComparison.OrdinalIgnoreCase))
{
FillPreset(Preset.Maximum, setting.CurrentConfusions);
}
else if (string.Equals(feature, "default", StringComparison.OrdinalIgnoreCase))
{
FillPreset(Preset.Normal, setting.CurrentConfusions);
}
else
{
ProcessConfig(feature, setting.CurrentConfusions);
}
}
return(exclude && applyToMembers);
}
catch
{
cr.Log("Warning: Cannot process ConfusingAttribute at '" + provider.ToString() + "'. ConfusingAttribute ignored.");
return(false);
}
}
