public FieldInfo resolve(FieldReference fieldReference)
{
var resolver = getTypeResolver(fieldReference.DeclaringType);
if (resolver != null)
return resolver.resolve(fieldReference);
return resolveGlobalField(fieldReference);
}
public WeakEventWeaver(FieldReference eventDelegate, ModuleImporter moduleimporter)
{
_eventDelegate = eventDelegate.Resolve();
_moduleimporter = moduleimporter;
_closedGenericEventHandler = moduleimporter.GetClosedEventHandlerT(eventDelegate.FieldType.GetEventArgsType());
_isGenericHandler = _closedGenericEventHandler.FullName.Equals(eventDelegate.FieldType.FullName);
}
public MField getField(FieldReference fieldReference)
{
initFields();
MField field;
fieldReferenceToField.TryGetValue(new FieldReferenceKey(fieldReference), out field);
return field;
}
public static FieldDefinition FindMatchingField(this TypeDefinition tdef, FieldReference fref, bool throwOnNotFound = false)
{
if (throwOnNotFound)
return tdef.Fields.First(fdef => fdef.FieldMatches(fref));
else
return tdef.Fields.FirstOrDefault(fdef => fdef.FieldMatches(fref));
}
MethodDefinition InjectMethod(TypeDefinition targetType, string eventInvokerName, FieldReference propertyChangingField)
{
var method = new MethodDefinition(eventInvokerName, GetMethodAttributes(targetType), ModuleDefinition.TypeSystem.Void);
method.Parameters.Add(new ParameterDefinition("propertyName", ParameterAttributes.None, ModuleDefinition.TypeSystem.String));
var handlerVariable = new VariableDefinition(PropChangingHandlerReference);
method.Body.Variables.Add(handlerVariable);
var boolVariable = new VariableDefinition(ModuleDefinition.TypeSystem.Boolean);
method.Body.Variables.Add(boolVariable);
var instructions = method.Body.Instructions;
var last = Instruction.Create(OpCodes.Ret);
instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
instructions.Add(Instruction.Create(OpCodes.Ldfld, propertyChangingField));
instructions.Add(Instruction.Create(OpCodes.Stloc_0));
instructions.Add(Instruction.Create(OpCodes.Ldloc_0));
instructions.Add(Instruction.Create(OpCodes.Ldnull));
instructions.Add(Instruction.Create(OpCodes.Ceq));
instructions.Add(Instruction.Create(OpCodes.Stloc_1));
instructions.Add(Instruction.Create(OpCodes.Ldloc_1));
instructions.Add(Instruction.Create(OpCodes.Brtrue_S, last));
instructions.Add(Instruction.Create(OpCodes.Ldloc_0));
instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
instructions.Add(Instruction.Create(OpCodes.Ldarg_1));
instructions.Add(Instruction.Create(OpCodes.Newobj, ComponentModelPropertyChangingEventConstructorReference));
instructions.Add(Instruction.Create(OpCodes.Callvirt, ComponentModelPropertyChangingEventHandlerInvokeReference));
instructions.Add(last);
method.Body.InitLocals = true;
targetType.Methods.Add(method);
return method;
}
private static MethodDefinition CreateEventRemoveMethod(AssemblyDefinition assemblyDefinition,
FieldReference propertyChangedFieldDefinition)
{
var removeMethodDefinition = assemblyDefinition.MainModule.Import(typeof(Delegate).GetMethod("Remove",
new[] { typeof(Delegate), typeof(Delegate) }));
var removePropertyChanged = new MethodDefinition("remove_PropertyChanged", MethodAttributes.Public |
MethodAttributes.SpecialName |
MethodAttributes.NewSlot |
MethodAttributes.HideBySig |
MethodAttributes.Virtual |
MethodAttributes.Final
, assemblyDefinition.MainModule.Import(typeof(void)));
removePropertyChanged.Overrides.Add(
assemblyDefinition.MainModule.Import(typeof(INotifyPropertyChanged).GetMethod("remove_PropertyChanged")));
removePropertyChanged.Parameters.Add(
new ParameterDefinition(assemblyDefinition.MainModule.Import(typeof(PropertyChangedEventHandler))));
var il = removePropertyChanged.Body.GetILProcessor();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, propertyChangedFieldDefinition);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Call, removeMethodDefinition);
il.Emit(OpCodes.Castclass, assemblyDefinition.MainModule.Import(typeof(PropertyChangedEventHandler)));
il.Emit(OpCodes.Stfld, propertyChangedFieldDefinition);
il.Emit(OpCodes.Ret);
return removePropertyChanged;
}
public void AddConstructor(TypeDefinition adapterType,
FieldReference targetField)
{
var adapterCtor = adapterType.AddDefaultConstructor();
var adapterParameter = new ParameterDefinition(_targetDependency);
adapterCtor.Parameters.Add(adapterParameter);
// HACK: Remove the ret instruction from the default constructor and replace it with
// the field setter
var adapterBody = adapterCtor.Body;
var adapterInstructions = adapterBody.Instructions.Cast<Instruction>().Where(i => i.OpCode != OpCodes.Ret).ToArray();
adapterBody.Instructions.Clear();
// Copy the old instructions
var IL = adapterBody.CilWorker;
foreach (var instruction in adapterInstructions)
{
IL.Append(instruction);
}
IL.Emit(OpCodes.Ldarg_0);
IL.Emit(OpCodes.Ldarg, adapterParameter);
IL.Emit(OpCodes.Stfld, targetField);
IL.Emit(OpCodes.Ret);
}
internal FieldReferenceReflectionEmitter(MemberReferenceExpression memberReferenceExpression,
Type target,
MemberInfo member,
ILGenerator ilGenerator,
IOpCodeIndexer instructionsIndexer,
IAstVisitor<ILGenerator, AstNode> visitor,
List<LocalBuilder> locals,
bool isSetter = false)
: base(memberReferenceExpression, target, member, ilGenerator, instructionsIndexer, visitor, locals) {
FieldReference = MemberReference.Annotation<FieldReference>();
IsByRef = MemberReference.Parent is DirectionExpression;
Type = FieldReference.FieldType.GetActualType();
FieldInfo = FieldReference.GetActualField();
NonPublic = !((FieldInfo.Attributes & (_publicFieldAttributes)) == _publicFieldAttributes);
if (isSetter) {
_emitAction = EmitStoreFieldReference;
_emitPrivateAction = EmitPrivateStoreFieldReference;
}
else {
_emitAction = EmitLoadFieldReference;
_emitPrivateAction = EmitPrivateLoadFieldReference;
}
}
public FieldReference convert(FieldReference fieldRef)
{
if (isInOurModule(fieldRef))
return tryGetFieldDefinition(fieldRef);
return new FieldReference(fieldRef.Name, convert(fieldRef.FieldType), convert(fieldRef.DeclaringType));
}
public static bool AlreadyHasEquality(PropertyDefinition propertyDefinition, FieldReference backingFieldReference)
{
var instructions = propertyDefinition.SetMethod.Body.Instructions;
var list = instructions.Where(IsNotNop).ToList();
if (list.Count < 4)
{
return false;
}
var firstFive = list.Take(5).ToList();
if (firstFive.All(x => x.OpCode != OpCodes.Ldarg_1))
{
return false;
}
if (firstFive.All(x => x.OpCode != OpCodes.Ldarg_0))
{
return false;
}
if (firstFive.All(x => !x.IsEquality()))
{
return false;
}
if (firstFive.Any(x => x.Operand == backingFieldReference))
{
return true;
}
if (firstFive.Any(x => x.Operand == propertyDefinition))
{
return true;
}
return false;
}
private static FieldReference FieldReferenceFor(FieldReference field)
{
if (!IsGeneric(field.DeclaringType)) return field;
var reference = new FieldReference(field.Name, field.FieldType);
reference.DeclaringType = GenericReferenceFor(field.DeclaringType);
return reference;
}
private void WeaveDependencyProperty(MethodBody staticCtorBody, FieldReference field, PropertyDefinition property)
{
var assembly = property.DeclaringType.Module.Assembly;
var propertyType = assembly.ImportType(Type.GetType(property.PropertyType.FullName));
var getTypeFromHandle = assembly.ImportMethod(typeof(Type).GetMethod("GetTypeFromHandle"));
var register = assembly.ImportMethod(typeof(DependencyProperty).GetMethod("Register", new[] { typeof(string), typeof(Type), typeof(Type) }));
// ignore previously weaved DPs
if (staticCtorBody.Instructions.Any(i => i.Operand != null && i.Operand.ToString() == field.ToString()))
{
return;
}
var ret = staticCtorBody.Instructions.Last();
if (ret.OpCode != OpCodes.Ret)
throw new InvalidOperationException("The last instruction should be OpCode.Ret");
HasChanges = true;
var proc = staticCtorBody.GetILProcessor();
proc.InsertBefore(ret, proc.Create(OpCodes.Ldstr, property.Name));
proc.InsertBefore(ret, proc.Create(OpCodes.Ldtoken, propertyType));
proc.InsertBefore(ret, proc.Create(OpCodes.Call, getTypeFromHandle));
proc.InsertBefore(ret, proc.Create(OpCodes.Ldtoken, property.DeclaringType));
proc.InsertBefore(ret, proc.Create(OpCodes.Call, getTypeFromHandle));
proc.InsertBefore(ret, proc.Create(OpCodes.Call, register));
proc.InsertBefore(ret, proc.Create(OpCodes.Stsfld, field));
}
private static void EmitArchsInit(MethodBody body, FieldReference archRef, Action<Instruction> emit)
{
var module = body.Method.Module;
GenericInstanceType dictStrStrRef = (GenericInstanceType)archRef.FieldType;
TypeReference dictOpenRef = dictStrStrRef.ElementType;
GenericInstanceType iEqCompStrRef = new GenericInstanceType(module.Import(typeof(IEqualityComparer<>)));
iEqCompStrRef.GenericArguments.Add(dictOpenRef.GenericParameters[0]);
MethodReference dictStrStrCtor = CecilUtils.ImportInstanceMethodRef(module, dictStrStrRef, ".ctor", null, iEqCompStrRef);
MethodReference dictAddRef = CecilUtils.ImportInstanceMethodRef(module, dictStrStrRef, "Add", null, dictOpenRef.GenericParameters[0], dictOpenRef.GenericParameters[1]);
// Variables
body.Variables.Add(new VariableDefinition(dictStrStrRef));
int varIdx = body.Variables.Count - 1;
Instruction varSt = CecilUtils.ShortestStloc(varIdx);
Instruction varLd = CecilUtils.ShortestLdloc(varIdx);
emit(Instruction.Create(OpCodes.Ldnull));
emit(Instruction.Create(OpCodes.Newobj, dictStrStrCtor));
emit(varSt.Clone());
emit(varLd.Clone());
emit(Instruction.Create(OpCodes.Stsfld, archRef));
Action<string, string> emitAddPair = (k, v) =>
{
emit(varLd.Clone());
emit(Instruction.Create(OpCodes.Ldstr, k));
emit(Instruction.Create(OpCodes.Ldstr, v));
emit(Instruction.Create(OpCodes.Callvirt, dictAddRef));
};
emitAddPair("x86", "Win32");
emitAddPair("AMD64", "x64");
emitAddPair("IA64", "Itanium");
emitAddPair("ARM", "WinCE");
}
public override void Visit(Model.Bytecode.LoadFieldInstruction instruction)
{
Cecil.FieldReference fieldReference = referenceGenerator.FieldReference(instruction.Field);
Mono.Cecil.Cil.Instruction cilIns;
if (instruction.Operation == Model.Bytecode.LoadFieldOperation.Content)
{
if (!instruction.Field.IsStatic)
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldfld, fieldReference);
}
else
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldsfld, fieldReference);
}
}
else
{
if (!instruction.Field.IsStatic)
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldflda, fieldReference);
}
else
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Ldsflda, fieldReference);
}
}
Result = new List <Mono.Cecil.Cil.Instruction>()
{
cilIns
};
}
public FieldNode(string name, SignatureNode type, bool isStatic = false, FieldReference field = null)
{
Name = name;
Field = field;
Type = type;
Static = isStatic;
}
public static FieldDefinition TryResolve(this IMetadataResolver metadataResolver, FieldReference fieldRef)
{
try {
return metadataResolver.Resolve(fieldRef);
} catch (AssemblyResolutionException) { }
return null;
}
MethodDefinition InjectValueConstructor(FieldReference valueField)
{
const MethodAttributes methodAttributes = MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName | MethodAttributes.HideBySig;
// public void .ctor(object value)
var constructor = new MethodDefinition(".ctor", methodAttributes,
ModuleDefinition.TypeSystem.Void);
constructor.Parameters.Add(new ParameterDefinition(
ModuleDefinition.TypeSystem.Object));
// base.ctor();
constructor.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
constructor.Body.Instructions.Add(Instruction.Create(OpCodes.Call,
new MethodReference(".ctor", ModuleDefinition.TypeSystem.Void,
ModuleDefinition.TypeSystem.Object) {HasThis = true}));
// this._value = value;
constructor.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
constructor.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_1));
constructor.Body.Instructions.Add(Instruction.Create(OpCodes.Stfld, valueField));
constructor.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
return constructor;
}
public ExprFieldAddress(Ctx ctx, Expr obj, FieldReference field)
: base(ctx) {
this.Obj = obj;
this.Field = field;
this.ElementType = field.FieldType.FullResolve(field);
this.type = this.ElementType.MakePointer();
}
public FieldDefinition Resolve (FieldReference field)
{
TypeDefinition type = Resolve (field.DeclaringType);
if (type == null)
return null;
return type.HasFields ? GetField (type.Fields, field) : null;
}
public FieldInfo Resolve(FieldReference fieldReference)
{
Type declaringType = _typeResolver.Resolve(fieldReference.DeclaringType);
var flags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public;
FieldInfo result = declaringType.GetField(fieldReference.Name, flags);
return result;
}
public Instruction Create (OpCode opcode, FieldReference field)
{
if (opcode.OperandType != OperandType.InlineField &&
opcode.OperandType != OperandType.InlineTok)
throw new ArgumentException ("opcode");
return FinalCreate (opcode, field);
}
public static FieldInfo getRtField(FieldReference fieldReference)
{
var mfield = getField(fieldReference);
if (mfield != null)
return mfield.fieldInfo;
return Resolver.resolve(fieldReference);
}
private AnalysisNet.IInstruction ProcessStoreField(Cecil.Cil.Instruction op)
{
Cecil.FieldReference cciField = op.Operand as Cecil.FieldReference;//op.Operand as Cci.IFieldReference;
AnalysisNet.Types.FieldReference ourField = typeExtractor.ExtractField(cciField, op.OpCode.Code == Cecil.Cil.Code.Stsfld);
AnalysisNetBytecode.StoreFieldInstruction instruction = new AnalysisNetBytecode.StoreFieldInstruction((uint)op.Offset, ourField);
return(instruction);
}
public void AddExternalFieldReference(MethodDefinition method, FieldReference attr)
{
// TODO: Why duplication? =\
if (!_externalFieldReferences.ContainsKey(method))
{
_externalFieldReferences.Add(method, attr);
}
}
private static void AddICollectionTProxy(ModuleDefinition moduleDefinition, TypeDefinition type, GenericInstanceType collectionT)
{
var itemType = collectionT.GenericArguments[0];
var itemArray = itemType.MakeArrayType();
var proxyType = CreateProxy(moduleDefinition, type);
TypeReference proxyTypeRef = proxyType;
if (type.HasGenericParameters)
proxyTypeRef = proxyType.MakeGenericInstanceType(type.GenericParameters.Select(gp => new GenericParameter(gp.Position, gp.Type, gp.Module)).ToArray());
var field = proxyType.Fields[0];
var fieldRef = new FieldReference(field.Name, field.FieldType, proxyTypeRef);
var countProperty = type.Properties.First(p => p.Name == "Count" || p.Name == "System.Collections.ICollection.Count");
MethodReference countMethod = countProperty.GetMethod;
MethodReference copyToMethod = type.Methods.First(p => p.Name == "CopyTo" || p.Name == "System.Collections.ICollection.CopyTo");
if (type.HasGenericParameters)
{
countMethod = countMethod.MakeHostInstanceGeneric(type.GenericParameters.Select(gp => new GenericParameter(gp.Position, gp.Type, gp.Module)).ToArray());
copyToMethod = copyToMethod.MakeHostInstanceGeneric(type.GenericParameters.Select(gp => new GenericParameter(gp.Position, gp.Type, gp.Module)).ToArray());
}
var getMethod = new MethodDefinition("get_Items", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, itemArray);
var getMethodBody = getMethod.Body;
var localItems = new VariableDefinition("items", itemArray);
getMethodBody.Variables.Add(localItems);
getMethodBody.SimplifyMacros();
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldfld, fieldRef));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Callvirt, countMethod));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Newarr, itemType));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Stloc, localItems));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldfld, fieldRef));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc, localItems));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc, localItems));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldlen));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Conv_I4));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Callvirt, copyToMethod));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ldloc, localItems));
getMethodBody.Instructions.Add(Instruction.Create(OpCodes.Ret));
getMethodBody.InitLocals = true;
getMethodBody.OptimizeMacros();
proxyType.Methods.Add(getMethod);
var property = new PropertyDefinition("Items", PropertyAttributes.None, itemArray);
property.GetMethod = getMethod;
var debuggerBrowsableAttribute = new CustomAttribute(ReferenceFinder.DebuggerBrowsableAttributeCtor);
debuggerBrowsableAttribute.ConstructorArguments.Add(new CustomAttributeArgument(ReferenceFinder.DebuggerBrowsableStateType, DebuggerBrowsableState.RootHidden));
property.CustomAttributes.Add(debuggerBrowsableAttribute);
proxyType.Properties.Add(property);
AddDebuggerTypeProxyAttribute(type, proxyType);
}
public static FieldReference MakeGeneric(this FieldReference field, TypeReference declaringType)
{
var reference = new FieldReference(field.Name, field.FieldType)
{
DeclaringType = declaringType.MakeGenericIfRequired(),
};
return reference;
}
public static MField getField(FieldReference fieldReference)
{
if (fieldReference == null)
return null;
var module = getModule(fieldReference.DeclaringType.Scope);
if (module != null)
return module.getField(fieldReference);
return null;
}
public FieldReference Resolve(FieldReference field)
{
TypeReference declaringType = this.Resolve(field.DeclaringType);
if (declaringType == field.DeclaringType)
{
return field;
}
return new FieldReference(field.Name, field.FieldType, declaringType);
}
FieldReference IImportMapper.MapField(FieldReference fref)
{
if (fref.DeclaringType.Scope.Name == _targetModule.Name)
return fref;
foreach (var cInj in _classInjectees.Where(i => i is TypeAddInjectee).Cast<TypeAddInjectee>())
{
var injCecilType = cInj.GetInjecteeCecilType(_injectionModule);
if (!fref.DeclaringType.TypeMatches(injCecilType))
continue;
var type = _targetModule.FindMatchingType(cInj.Import(_targetModule, fref.DeclaringType.Scope, this));
if (type == null)
throw new InvalidOperationException("Unable to find add class for: " + fref.DeclaringType);
var field = type.FindMatchingField(fref, true);
var decl = FixTypeImport(_targetModule, fref.DeclaringType);
return new FieldReference(field.Name, field.FieldType, decl);
}
foreach (var cInj in _classInjectees.Where(i => i is TypeTargetInjecteeBase))
{
var injCecilType = cInj.GetInjecteeCecilType(_injectionModule);
if (!fref.DeclaringType.TypeMatches(injCecilType))
continue;
var classInjectee = cInj as TypeInjectee;
var classStubInjectee = cInj as TypeStubInjectee;
if (classInjectee != null)
{
foreach (var inj in classInjectee.Injectees.Where(i => i is FieldInjecteeBase).Cast<FieldInjecteeBase>())
{
if (!fref.FieldMatches(inj.InjecteeField))
continue;
if (inj is FieldStubInjectee)
return ((FieldStubInjectee)inj).GetTargetCecilDefintion(_targetModule);
}
}
else if (classStubInjectee != null)
{
var stubTargetClass = classStubInjectee.TargetType;
var tdef = _targetModule.FindMatchingType(stubTargetClass);
if (tdef == null)
throw new InvalidOperationException("Type not found for: " + stubTargetClass.Name);
var target = tdef.FindMatchingField(fref);
if (target == null)
throw new InvalidOperationException("Target field not found for: " + stubTargetClass.Name);
return target;
}
}
return null;
}
public Coupling(string to, bool isReadOnly, bool ignoreWalk, bool isSelfCall, FieldReference fieldReference, MemberReference actualReference)
{
To = to;
FieldReference = fieldReference;
IsSelfCall = isSelfCall;
IsReadOnly = isReadOnly;
IgnoreWalk = ignoreWalk;
ActualReference = actualReference;
}
public MemberAccess(MemberReference memberReference, bool isReadOnly, bool isSelfCall, FieldReference onField, MethodReference actualMethodDefinition, bool isLocalVariable)
{
MemberReference = memberReference;
IsLocalVariable = isLocalVariable;
OnField = onField;
IsSelfCall = isSelfCall;
IsReadOnly = isReadOnly;
ActualMethodDefinition = actualMethodDefinition;
}
public static bool compareFields(FieldInfo a, FieldReference b)
{
if (a == null && b == null)
return true;
if (a == null || b == null)
return false;
return a.Name == b.Name &&
compareTypes(a.FieldType, b.FieldType);
}
private AnalysisNet.IInstruction ProcessLoadField(Cecil.Cil.Instruction op)
{
AnalysisNetBytecode.LoadFieldOperation operation = OperationHelper.ToLoadFieldOperation(op.OpCode.Code);
Cecil.FieldReference cciField = op.Operand as Cecil.FieldReference;
bool isStatic = op.OpCode.Code == Cecil.Cil.OpCodes.Ldsfld.Code || op.OpCode.Code == Cecil.Cil.OpCodes.Ldsflda.Code;
AnalysisNet.Types.FieldReference ourField = typeExtractor.ExtractField(cciField, isStatic);
AnalysisNetBytecode.LoadFieldInstruction instruction = new AnalysisNetBytecode.LoadFieldInstruction((uint)op.Offset, operation, ourField);
return(instruction);
}
public AnalysisNet.Types.FieldReference ExtractField(Cecil.FieldReference field, bool isStatic)
{
(Cecil.FieldReference, bool)key = ValueTuple.Create(field, isStatic);
return(performanceCache.GetOrCreate(key, (cacheEntry) =>
{
AnalysisNet.Types.FieldReference analysisNetField = new AnalysisNet.Types.FieldReference(field.Name, ExtractType(field.FieldType))
{
ContainingType = (AnalysisNet.Types.IBasicType)ExtractType(field.DeclaringType),
IsStatic = isStatic
};
return analysisNetField;
}));
}
/// <summary>
/// Gets the converted name of the given field.
/// </summary>
public static string GetConvertedName(FieldReference field)
{
var name = field.Name;
var originalName = name;
name = name.Replace('<', '_');
name = name.Replace('>', '_');
if (name != originalName)
{
// Add hash to ensure unique
name = name + GetHashPostfix(originalName);
}
return(name);
}
public override void Visit(Model.Bytecode.StoreFieldInstruction instruction)
{
Mono.Cecil.Cil.Instruction cilIns;
Cecil.FieldReference fieldReference = referenceGenerator.FieldReference(instruction.Field);
if (!instruction.Field.IsStatic)
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Stfld, fieldReference);
}
else
{
cilIns = processor.Create(Mono.Cecil.Cil.OpCodes.Stsfld, fieldReference);
}
Result = new List <Mono.Cecil.Cil.Instruction>()
{
cilIns
};
}
public Cecil.FieldReference FieldReference(AnalysisNet.Types.IFieldReference fieldReference)
{
if (fieldsCache.TryGetValue(fieldReference, out Cecil.FieldReference cecilField))
{
return(cecilField);
}
Cecil.TypeReference cecilType = TypeReference(fieldReference.Type);
Cecil.TypeReference declaringType = TypeReference(fieldReference.ContainingType);
cecilField = new Cecil.FieldReference(
fieldReference.Name,
cecilType,
declaringType
);
fieldsCache[fieldReference] = cecilField;
return(cecilField);
}
public override void Visit(Model.Bytecode.LoadTokenInstruction instruction)
{
Cecil.Cil.Instruction cilIns;
if (instruction.Token is AnalysisNet.Types.IType type)
{
Cecil.TypeReference token = referenceGenerator.TypeReference(type);
cilIns = processor.Create(Cecil.Cil.OpCodes.Ldtoken, token);
}
else if (instruction.Token is AnalysisNet.Types.IFieldReference field)
{
Cecil.FieldReference token = referenceGenerator.FieldReference(field);
cilIns = processor.Create(Cecil.Cil.OpCodes.Ldtoken, token);
}
else
{
throw new NotImplementedException();
}
Result = new List <Mono.Cecil.Cil.Instruction>()
{
cilIns
};
}
private AnalysisNet.Types.VisibilityKind ExtractVisibilityKind(Cecil.FieldReference field)
{
return(AnalysisNet.Types.VisibilityKind.Public);
}
public static FieldReference ImportEx(this ModuleDefinition module, FieldReference field)
{
return(module.ImportReference(field));
}
public FieldReference ImportReference(FieldReference field)
{
return(ImportReference(field, null));
}
public static FieldReference ImportEx(this ModuleDefinition module, FieldReference field, IGenericParameterProvider context)
{
return(module.ImportReference(field, context));
}
internal static TypeReference ResolveFieldTypeIfNeeded(FieldReference fieldReference)
{
return(ResolveIfNeeded(null, fieldReference.DeclaringType as GenericInstanceType, fieldReference.FieldType));
}
void EmitInstruction(ILGenerator il, OpCode opcode, Cecil.FieldReference operandField)
{
var ourType = FindType(operandField.DeclaringType);
il.Emit(opcode, ourType.GetField(operandField.Name, bindingAttr: bflags_all));
}
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 FieldReference Import(FieldReference field, IGenericParameterProvider context)
{
return(ImportReference(field, context));
}
static public int Emit(this MethodBody body, OpCode instruction, FieldReference field)
{
return(body.Add(Instruction.Create(instruction, field)));
}
static public FieldReference Reference(this GenericInstanceType genericInstanceType, FieldReference field)
{
var _fieldReference = new FieldReference(field.Name, field.FieldType, genericInstanceType);
return(_fieldReference);
}
public static FieldReference MakeGeneric(this FieldReference self, params TypeReference[] arguments)
{
return(new FieldReference(self.Name, self.FieldType, self.DeclaringType.MakeGenericType(arguments)));
}
internal FieldDefinition Resolve(FieldReference field)
{
return(MetadataResolver.Resolve(field));
}
public FieldReference Import(FieldReference field, MethodReference context)
{
return(Import(field, (IGenericParameterProvider)context));
}
static FieldDefinition GetField(IAssemblyResolver resolver, TypeDefinition type, FieldReference reference)
{
while (type != null)
{
var field = GetField(type.Fields, reference);
if (field != null)
{
return(field);
}
if (type.BaseType == null)
{
return(null);
}
type = Resolve(resolver, type.BaseType);
}
return(null);
}
public virtual FieldReference ImportReference(FieldReference field, IGenericParameterProvider context)
{
Mixin.CheckField(field);
return(ImportField(field, ImportGenericContext.For(context)));
}