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);
}
