public static string[] GetGenericName(Mono.Collections.Generic.Collection <TypeReference> types, int offset, int count, bool bFull)
{
string[] results = new string[count];
for (int i = 0; i < count; i++)
{
int pos = i + offset;
if (types[pos].IsGenericInstance)
{
results[i] = GetGenericName(types[pos], bFull);
}
else
{
results[i] = GetTypeName(types[pos]);
}
}
return(results);
}
static public int Emit(this MethodBody body, OpCode instruction, TypeReference type, Mono.Collections.Generic.Collection <ParameterDefinition> parameters)
{
if (instruction == OpCodes.Calli)
{
var _signature = new CallSite(type);
foreach (var _parameter in parameters)
{
_signature.Parameters.Add(_parameter);
}
_signature.CallingConvention = MethodCallingConvention.Default;
return(body.Add(Mono.Cecil.Cil.Instruction.Create(instruction, _signature)));
}
throw new InvalidOperationException();
}
private StringBuilder AppendConstraints(StringBuilder buf, IList <GenericParameter> genArgs)
{
foreach (GenericParameter genArg in genArgs)
{
GenericParameterAttributes attrs = genArg.Attributes;
#if NEW_CECIL
Mono.Collections.Generic.Collection <GenericParameterConstraint> constraints = genArg.Constraints;
#else
IList <TypeReference> constraints = genArg.Constraints;
#endif
if (attrs == GenericParameterAttributes.NonVariant && constraints.Count == 0)
{
continue;
}
bool isref = (attrs & GenericParameterAttributes.ReferenceTypeConstraint) != 0;
bool isvt = (attrs & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0;
bool isnew = (attrs & GenericParameterAttributes.DefaultConstructorConstraint) != 0;
bool comma = false;
if (!isref && !isvt && !isnew && constraints.Count == 0)
{
continue;
}
buf.Append(" where ").Append(genArg.Name).Append(" : ");
if (isref)
{
buf.Append("class");
comma = true;
}
else if (isvt)
{
buf.Append("value class");
comma = true;
}
if (constraints.Count > 0 && !isvt)
{
if (comma)
{
buf.Append(", ");
}
#if NEW_CECIL
buf.Append(GetTypeName(constraints[0].ConstraintType));
for (int i = 1; i < constraints.Count; ++i)
{
buf.Append(", ").Append(GetTypeName(constraints[i].ConstraintType));
}
#else
buf.Append(GetTypeName(constraints[0]));
for (int i = 1; i < constraints.Count; ++i)
{
buf.Append(", ").Append(GetTypeName(constraints[i]));
}
#endif
}
if (isnew && !isvt)
{
if (comma)
{
buf.Append(", ");
}
buf.Append("gcnew()");
}
}
return(buf);
}
private void AppendConstraints(StringBuilder buf, IList <GenericParameter> genArgs)
{
var origMemberFormatterState = MemberFormatterState;
MemberFormatterState = MemberFormatterState.WithinGenericTypeParameters;
List <string> constraintStrings = new List <string>();
foreach (GenericParameter genArg in genArgs.Where(i => !IsFlexibleType(i)))
{
GenericParameterAttributes attrs = genArg.Attributes;
#if NEW_CECIL
Mono.Collections.Generic.Collection <GenericParameterConstraint> constraints = genArg.Constraints;
#else
IList <TypeReference> constraints = genArg.Constraints;
#endif
if (attrs == GenericParameterAttributes.NonVariant && constraints.Count == 0)
{
continue;
}
bool isref = (attrs & GenericParameterAttributes.ReferenceTypeConstraint) != 0;
bool isvt = (attrs & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0;
bool isnew = (attrs & GenericParameterAttributes.DefaultConstructorConstraint) != 0;
if (!isref && !isvt && !isnew && constraints.Count == 0)
{
continue;
}
var genericName = GetGenericName(genArg.Name);
if (isref)
{
// May be "not struct". We don't know it here
constraintStrings.Add($"{genericName} : null");
}
else if (isvt)
{
constraintStrings.Add($"{genericName} : struct");
}
if (constraints.Count > 0 && !isvt)
{
foreach (var typeReference in constraints)
{
#if NEW_CECIL
constraintStrings.Add($"{genericName} :> {GetTypeName(typeReference.ConstraintType)}");
#else
constraintStrings.Add($"{genericName} :> {GetTypeName(typeReference)}");
#endif
}
}
if (isnew && !isvt)
{
constraintStrings.Add($"{genericName} : (new : unit -> {GetTypeName(genArg)})");
}
}
if (constraintStrings.Count > 0)
{
buf.Append($" (requires {string.Join(" and ", constraintStrings)})");
}
MemberFormatterState = origMemberFormatterState;
}
public static List <FieldDefinition> GetEnumFieldDefinitionByValue(Mono.Collections.Generic.Collection <FieldDefinition> fieldDefinitions, object value, Collection <Mono.Cecil.CustomAttribute> customAttributes)
{
bool flagsEnum = false;
foreach (CustomAttribute attribute in customAttributes)
{
if (attribute.AttributeType.FullName == "System.FlagsAttribute")
{
flagsEnum = true;
}
}
long valueAsInt64;
if (value is string)
{
if (!long.TryParse((string)value, out valueAsInt64))
{
valueAsInt64 = 0;
}
}
else
{
valueAsInt64 = Convert.ToInt64(value);
}
List <FieldDefinition> result = new List <Mono.Cecil.FieldDefinition>();
for (int i = 1; i < fieldDefinitions.Count; i++)
{
if (fieldDefinitions[i].Constant == null || fieldDefinitions[i].Constant.Value == null)
{
continue;
}
//Checking whether value corresponds directly to an enum field
if (fieldDefinitions[i].Constant.Value.Equals(value))
{
result.Clear();
result.Add(fieldDefinitions[i]);
return(result);
}
if (flagsEnum)
{
////After this there might be duplicates, i.e. assuming that there are enum.A, enum.B and enum.AB where enum.AB = enum.A | enum.B all the three are gonna be present in the result.
////Which is correct although ugly. TODO: Fix duplication of flags in enums.
//Assuming the largest underlying type of an enum is 64-bit signed/unsigned int
long enumConstantasInt64 = Convert.ToInt64(fieldDefinitions[i].Constant.Value);
if (enumConstantasInt64 != 0)
{
if ((enumConstantasInt64 & valueAsInt64) == enumConstantasInt64)
{
result.Add(fieldDefinitions[i]);
}
}
else
{
if (valueAsInt64 == 0)
{
result.Add(fieldDefinitions[i]);
}
}
}
}
return(result);
}