public override Func <IExtractContext, string[]> Apply( ParameterReference operand, DecodeContext decodeContext) { var index = operand.Resolve().Method.HasThis ? (operand.Index + 1) : operand.Index; return(LdargConverterUtilities.Apply(index, decodeContext)); }
private IParameterInformation ToParameterInformation(ParameterReference parameter) => new ParameterInformation( this, this.HasThis ? (parameter.Index + 1) : parameter.Index, parameter.Name, this.MetadataContext.GetOrAddType(parameter.ParameterType), parameter.Resolve().CustomAttributes.ToArray());
public void Collect(ParameterReference parm) { ParameterDefinition def; if ((def = parm as ParameterDefinition ?? parm.Resolve()) != null) { Collect(def); } }
public static ParameterDefinition TryResolve(this ParameterReference r) { try { return(r.Resolve()); } catch (Exception) { return(null); } }
public override ICodeNode VisitArgumentReferenceExpression(ArgumentReferenceExpression node) { ParameterReference parameterReference = node.Parameter; VariableReference variableReference; if (parameterToVariableMap.TryGetValue(parameterReference.Resolve(), out variableReference)) { return(new VariableReferenceExpression(variableReference, node.UnderlyingSameMethodInstructions)); } return(node); }
private bool IsSerializedParameter(MethodDefinition method, ParameterReference @ref) { var paramDef = @ref.Resolve(); if (paramDef == null) { return(false); } if (paramDef.IsSerializedParameter.HasValue) { return(paramDef.IsSerializedParameter.Value); } bool isSerialized = paramDef.HasSerializedParameterAttribute(); if (!isSerialized) { // check inheritance var baseMethod = method.GetBaseMethod(); if (baseMethod != null) { isSerialized = IsSerializedParameter(baseMethod, baseMethod.Parameters[@ref.Index]); } } if (!isSerialized) { // check interfaces. isSerialized = method.GetBaseInterfaceMethods() .Any(im => IsSerializedParameter(im, im.Parameters[@ref.Index])); } paramDef.IsSerializedParameter = isSerialized; return(isSerialized); }
/// <summary> /// An argument code. /// </summary> /// <param name="parameter">The parameter.</param> /// <returns></returns> public static Instruction Arg(ParameterReference parameter) => Instruction.Create(OpCodes.Ldarg, parameter.Resolve());
public static void WriteOperand(ITextOutput writer, object operand) { if (operand == null) { throw new ArgumentNullException(nameof(operand)); } Instruction targetInstruction = operand as Instruction; if (targetInstruction != null) { WriteOffsetReference(writer, targetInstruction); return; } Instruction[] targetInstructions = operand as Instruction[]; if (targetInstructions != null) { WriteLabelList(writer, targetInstructions); return; } VariableReference variableRef = operand as VariableReference; if (variableRef != null) { writer.WriteReference(variableRef.Index.ToString(), variableRef); return; } ParameterReference paramRef = operand as ParameterReference; if (paramRef != null) { if (string.IsNullOrEmpty(paramRef.Name)) { var paramDef = paramRef.Resolve(); writer.WriteReference((paramDef == null ? paramRef.Index : paramDef.Sequence).ToString(), paramRef); } else { writer.WriteReference(Escape(paramRef.Name), paramRef); } return; } MethodReference methodRef = operand as MethodReference; if (methodRef != null) { methodRef.WriteTo(writer); return; } TypeReference typeRef = operand as TypeReference; if (typeRef != null) { typeRef.WriteTo(writer, ILNameSyntax.TypeName); return; } FieldReference fieldRef = operand as FieldReference; if (fieldRef != null) { fieldRef.WriteTo(writer); return; } string s = operand as string; if (s != null) { WriteOperand(writer, s); } else if (operand is char) { writer.Write(((int)(char)operand).ToString()); } else if (operand is float) { WriteOperand(writer, (float)operand); } else if (operand is double) { WriteOperand(writer, (double)operand); } else if (operand is bool) { writer.Write((bool)operand ? "true" : "false"); } else { s = ToInvariantCultureString(operand); writer.Write(s); } }
/// <summary> /// A cecil parameter 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(ParameterReference item, out object resolvedItem) { resolvedItem = item.Resolve(); return(true); }