public CecilDictionaryEntityNames(PropertyReference property)
: base(
property.DeclaringType.Namespace,
property.DeclaringType.Name,
property.Name,
property.DeclaringType.Module.Assembly.Name.Name)
{
}
/// <summary>
/// Adds a new property name mapping.
/// </summary>
/// <param name="property">The original property reference.</param>
/// <param name="obfuscatedPropertyName">Name of the obfuscated property.</param>
public void AddPropertyMapping(PropertyReference property, string obfuscatedPropertyName)
{
if (property == null) throw new ArgumentNullException("property");
string propertyName = property.Name;
if (!properties.ContainsKey(propertyName))
{
properties.Add(propertyName, new MemberMapping(propertyName, obfuscatedPropertyName));
obfuscatedProperties.Add(obfuscatedPropertyName, property);
}
}
public static bool AreSame(PropertyReference a, PropertyReference b)
{
if (a.Name != b.Name)
return false;
if (!AreSame(a.PropertyType, b.PropertyType))
return false;
if (!AreSame(a.DeclaringType, b.DeclaringType))
return false;
if (!AreSame(a.Parameters, b.Parameters))
return false;
return true;
}
/// <summary>
/// Gets the converted name of the given property.
/// </summary>
public static string GetConvertedName(PropertyReference property)
{
var name = property.Name;
var originalName = name;
name = name.Replace('<', '_');
name = name.Replace('>', '_');
if (name != originalName)
{
// Add hash to ensure unique
name = name + GetHashPostfix(originalName);
}
return name;
}
void addPropertyReference(PropertyReference propertyReference)
{
if (propertyReference == null)
return;
addMemberReference(propertyReference);
pushMember(propertyReference.PropertyType);
}
private static string Format(PropertyReference property)
{
var sb = new StringBuilder();
sb.Append(CecilFormat.GetTypeName(property.DeclaringType));
sb.Append('.');
sb.Append(property.Name);
return sb.ToString();
}
private void MergeReference(DeepCopier copier, PropertyReference @ref1, PropertyReference @re2)
{
}
private static void CreateWellName(PropertyReference pr)
{
var name = CleanName(pr.Name);
var start = name.IndexOf(NONWELLFLAG);
if (start == -1 && pr.Parameters.Count == 0)
{
if (IsNameRepeated(pr.DeclaringType, name)) name += "_" + GetShortName(pr.PropertyType);
}
else
{
var pd = pr.Resolve();
if (pd != null)
{
var pdJust = pd;
var accessor = pd.GetMethod ?? pd.SetMethod;
if (accessor != null && accessor.HasOverrides)
{
var baseAccessor = accessor.Overrides.First().Resolve();
pdJust = baseAccessor.DeclaringType.Properties.First(x => x.GetMethod == baseAccessor || x.SetMethod == baseAccessor);
name = baseAccessor.Name.Substring(4);
start = name.IndexOf(NONWELLFLAG);
}
else
{
// 重载属性，但没有 Overrides ?????
}
if (pd.HasParameters)
{
// 将具有参数的缺省属性修改为索引器
//[DefaultMember("Item")]
//public class MyClass
//{
// public double P_1_double
// {
// get { switch (e_1) { …… } }
// set { switch (e_1) { …… } }
// }
// ……
//}
//====>
//public class MyClass
//{
// public double this[int e_1]
// {
// get { switch (e_1) { …… } }
// set { switch (e_1) { …… } }
// }
// ……
//}
pr.mWellName = GetDefaultMemberName(pdJust.DeclaringType) ?? "Item";
return;
}
}
if (start >= 0) name = Replace(name, start, 1, "P") + "_" + GetShortName(pr.PropertyType);
}
pr.mWellName = Regex.Replace(name, @"\W", "_");
}
public PropertyReferenceKey(PropertyReference propRef)
{
this.propRef = propRef;
}
public static bool comparePropertyReference(PropertyReference a, PropertyReference b)
{
if (ReferenceEquals(a, b))
return true;
if (a == null || b == null)
return false;
if ((a.Parameters == null && b.Parameters != null) || (a.Parameters != null && b.Parameters == null))
return false;
if (a.Parameters != null) {
if (a.Parameters.Count != b.Parameters.Count)
return false;
for (int i = 0; i < a.Parameters.Count; i++) {
if (!compareTypes(a.Parameters[i].ParameterType, b.Parameters[i].ParameterType))
return false;
}
}
return a.Name == b.Name &&
compareTypes(a.PropertyType, b.PropertyType);
}
public override void VisitPropertyReference(PropertyReference property)
{
var propertyReference = property;
var scope = GetAssemblyNameReference(propertyReference.DeclaringType.Scope);
MapReference(scope, propertyReference);
}
/// <summary>
/// Gets the name of the obfuscated property.
/// </summary>
/// <param name="property">The original property reference.</param>
/// <returns></returns>
public string GetObfuscatedPropertyName(PropertyReference property)
{
if (property == null) throw new ArgumentNullException("property");
if (HasPropertyMapping(property))
{
string propertyName = property.Name;
return properties[propertyName].ObfuscatedMemberName;
}
return null;
}
/// <summary>
/// Determines whether a property mapping exists for the specified property name.
/// </summary>
/// <param name="property">The original property reference.</param>
/// <returns>
/// <c>true</c> if a property mapping exists; otherwise, <c>false</c>.
/// </returns>
public bool HasPropertyMapping(PropertyReference property)
{
if (property == null) throw new ArgumentNullException("property");
string propertyName = property.Name;
return properties.ContainsKey(propertyName);
}
protected override string GetPropertyName(PropertyReference property)
{
return (writerContext == null || writerContext.ModuleContext.Module == null) ? property.Name : base.GetPropertyName(property);
}
/// <summary>
/// Are the given properties the same?
/// </summary>
public static bool AreSame(this PropertyReference a, PropertyReference b, Func<GenericParameter, TypeReference> genericParamResolver)
{
var parametersA = a.Parameters;
var parametersB = b.Parameters;
if (parametersA.Count != parametersB.Count)
return false;
if (a.Name != b.Name)
return false;
if (!a.PropertyType.AreSame(b.PropertyType, genericParamResolver))
return false;
if (!parametersA.AreSame(parametersB, genericParamResolver))
return false;
return true;
}
/// <summary>
/// A cecil property reference will be directed to this method.
/// </summary>
/// <param name="item">Cecil reference.</param>
/// <param name="resolvedItem">Output parameter that will be populated with the resolved cecil definition.</param>
/// <returns><c>true</c></returns>
private static bool TryResolve(PropertyReference item, out object resolvedItem)
{
resolvedItem = item.Resolve();
return true;
}
public static string Disassemble(DomCecilMethod method, bool markup)
{
if (method.MethodDefinition.IsPInvokeImpl)
{
return(GettextCatalog.GetString("Method is P/Invoke"));
}
if (method.MethodDefinition.Body == null)
{
IType type = method.DeclaringType;
return(type == null || type.ClassType == ClassType.Interface ? GettextCatalog.GetString("Interface method") : GettextCatalog.GetString("Abstract method"));
}
StringBuilder result = new StringBuilder();
foreach (Instruction instruction in method.MethodDefinition.Body.Instructions)
{
if (markup)
{
result.Append("<b>");
}
result.Append(GetInstructionOffset(instruction));
result.Append(markup ? ":</b> " : ": ");
result.Append(instruction.OpCode);
if (markup)
{
result.Append("<i>");
}
if (instruction.Operand != null)
{
result.Append(' ');
if (instruction.Operand is string)
{
result.Append('"');
result.Append(AssemblyBrowserWidget.FormatText(instruction.Operand.ToString()));
result.Append('"');
}
else if (instruction.Operand is Mono.Cecil.Cil.Instruction)
{
result.Append(GetInstructionOffset((Mono.Cecil.Cil.Instruction)instruction.Operand));
}
else if (instruction.Operand is Mono.Cecil.TypeDefinition)
{
AppendLink(result,
new DomCecilType((Mono.Cecil.TypeDefinition)instruction.Operand).HelpUrl,
instruction.Operand.ToString());
}
else if (instruction.Operand is Mono.Cecil.MethodDefinition)
{
Mono.Cecil.MethodDefinition md = instruction.Operand as Mono.Cecil.MethodDefinition;
AppendLink(result,
new DomCecilMethod(md)
{
DeclaringType = new DomCecilType(md.DeclaringType)
}.HelpUrl,
instruction.Operand.ToString());
}
else if (instruction.Operand is Mono.Cecil.FieldDefinition)
{
Mono.Cecil.FieldDefinition fd = instruction.Operand as Mono.Cecil.FieldDefinition;
AppendLink(result,
new DomCecilField(fd)
{
DeclaringType = new DomCecilType(fd.DeclaringType)
}.HelpUrl,
instruction.Operand.ToString());
}
else if (instruction.Operand is Mono.Cecil.PropertyDefinition)
{
Mono.Cecil.PropertyDefinition pd = instruction.Operand as Mono.Cecil.PropertyDefinition;
AppendLink(result,
new DomCecilProperty(pd)
{
DeclaringType = new DomCecilType(pd.DeclaringType)
}.HelpUrl,
instruction.Operand.ToString());
}
else if (instruction.Operand is Mono.Cecil.TypeReference)
{
AppendLink(result,
"T:" + ((TypeReference)instruction.Operand).FullName,
instruction.Operand.ToString());
}
else if (instruction.Operand is Mono.Cecil.MethodReference)
{
Mono.Cecil.MethodReference mr = instruction.Operand as Mono.Cecil.MethodReference;
StringBuilder id = new StringBuilder(mr.DeclaringType.ToString());
bool isConstructor = mr.Name == ".ctor";
if (!isConstructor)
{
id.Append("." + mr.Name);
}
id.Append("(");
for (int i = 0; i < mr.Parameters.Count; i++)
{
if (i > 0)
{
id.Append(',');
}
id.Append(mr.Parameters[i].ParameterType.FullName);
}
id.Append(")");
AppendLink(result, (isConstructor ? "C:" : "M:") + id, id.ToString());
}
else if (instruction.Operand is Mono.Cecil.FieldReference)
{
Mono.Cecil.FieldReference fr = instruction.Operand as Mono.Cecil.FieldReference;
string id = fr.DeclaringType + "." + fr.Name;
AppendLink(result, "F:" + id, id);
}
else if (instruction.Operand is Mono.Cecil.PropertyReference)
{
Mono.Cecil.PropertyReference pr = instruction.Operand as Mono.Cecil.PropertyReference;
string id = pr.DeclaringType + "." + pr.Name;
AppendLink(result, "P:" + id, id);
}
else
{
result.Append(AssemblyBrowserWidget.FormatText(instruction.Operand.ToString()));
}
}
if (markup)
{
result.Append("</i>");
}
result.AppendLine();
}
result.AppendLine();
return(result.ToString());
}
public static int propertyReferenceHashCode(PropertyReference a)
{
if (a == null)
return 0;
int res = 0;
if (a.Parameters != null) {
res += a.Parameters.Count.GetHashCode();
foreach (var param in a.Parameters)
res += typeHashCode(param.ParameterType);
}
res += a.Name.GetHashCode();
res += typeHashCode(a.PropertyType);
return res;
}
public PropertyReferenceExpression (Expression target, PropertyReference property)
{
_target = target;
_property = property;
}
public ScopeAndTokenKey(PropertyReference prop)
: this(prop.DeclaringType == null ? null : prop.DeclaringType.Scope, prop.MetadataToken.ToInt32())
{
}
/// <summary>
/// Mark all eachable items in argument as such.
/// </summary>
private static void Walk(ReachableContext context, PropertyReference prop)
{
prop.PropertyType.MarkReachable(context);
// Parameters
if (prop.Parameters.Count > 0)
{
foreach (ParameterDefinition param in prop.Parameters)
{
Walk(context, (ParameterReference)param);
}
}
var propDef = prop as PropertyDefinition;
if (propDef != null)
{
// DO NOT AUTOMATICALLY MAKE GET and SET REACHABLE.
//propDef.GetMethod.MarkReachable(context);
//propDef.SetMethod.MarkReachable(context);
// Custom attributes
Walk(context, (ICustomAttributeProvider)propDef);
}
else
{
// Try to resolve
prop.Resolve(context).MarkReachable(context);
}
}
public virtual TypeReference Import(PropertyReference property)
{
return AssemblyDefinition.MainModule.Import(property.PropertyType);
}
/// <summary>
/// Mark all reachable items in argument as such.
/// </summary>
private static void Walk(ReachableContext context, PropertyReference prop)
{
prop.PropertyType.MarkReachable(context, prop.IsUsedInSerialization);
// Parameters
if (prop.Parameters.Count > 0)
{
foreach (ParameterDefinition param in prop.Parameters)
{
Walk(context, (ParameterReference)param);
}
}
var propDef = prop as PropertyDefinition;
if (propDef != null)
{
// DO NOT AUTOMATICALLY MAKE GET and SET REACHABLE.
// (but do so for attributes, so that they can
// be properly stored and loaded)
if (prop.DeclaringType.Resolve().IsAttribute())
{
propDef.GetMethod.MarkReachable(context);
propDef.SetMethod.MarkReachable(context);
}
else if (prop.IsUsedInSerialization || propDef.IsUsedInSerialization)
{
propDef.GetMethod.MarkReachable(context);
propDef.SetMethod.MarkReachable(context);
}
// Custom attributes
Walk(context, (ICustomAttributeProvider)propDef);
}
else
{
// Try to resolve
prop.Resolve(context).MarkReachable(context, prop.IsUsedInSerialization);
}
}
private IEnumerable<ProjectReference> GetPropertyParametersReferences(
PropertyReference propertyReference, AuditEntryParameters parameters)
{
foreach(var projectReference in GetTypeReferences(propertyReference.PropertyType, parameters))
yield return projectReference;
foreach (var paramDefinition in propertyReference.Parameters)
{
foreach(var projectReference in
GetTypeReferences(paramDefinition.ParameterType, parameters))
yield return projectReference;
}
}
public static PropertyReference GetTypePropertyDef(TypeDefinition destType, PropertyReference origProperty)
{
return GetTypePropertyDef(destType, origProperty.Name, origProperty.PropertyType.FullName);
}
public PropertyRef(PropertyReference propertyReference, TypeDef owner, int index)
: base(propertyReference, owner, index)
{
}
internal PropertyInfo ResolveProperty(PropertyReference reference)
{
Type returnType = ResolveType(reference.PropertyType);
Type[] parameterTypes = ResolveParameterTypes(reference.Parameters);
Type type = ResolveType(reference.DeclaringType);
return GetProperty(type, reference.Name, returnType, parameterTypes);
}
public PropertyDef findAny(PropertyReference pr)
{
return properties.findAny(pr);
}
public PropertyReferenceExpression (Expression target, PropertyReference property)
{
this.target = target;
this.property = property;
}
protected virtual string GetPropertyName(PropertyReference property)
{
PropertyDefinition propertyDefinition = property.Resolve();
if (propertyDefinition != null && propertyDefinition.Module.FilePath == this.ModuleContext.Module.FilePath)
{
try
{
return this.ModuleContext.RenamedMembersMap[propertyDefinition.MetadataToken.ToUInt32()];
}
catch (Exception ex)
{
Write(propertyDefinition.MetadataToken.ToUInt32().ToString());
WriteLine();
Write(ModuleContext.RenamedMembersMap.Count.ToString());
WriteLine();
foreach (KeyValuePair<uint, string> pair in ModuleContext.RenamedMembersMap)
{
Write(pair.Key.ToString() + " " + pair.Value);
WriteLine();
}
throw ex;
}
}
return Utilities.EscapeName(GenericHelper.GetNonGenericName(property.Name), this.Language);
}
public static PropertyDefinition TryResolve(this ModuleDefinition scope, PropertyReference propertyRef)
{
var matchingType = TryResolve(scope, propertyRef.DeclaringType);
if (matchingType == null) {
return null;
}
return matchingType.Properties.FirstOrDefault(e => e.Name == propertyRef.Name);
}
