internal static CilTypeSpecification Create(TypeSpecification typeSpecification, ref CilReaders readers)
{
CilTypeSpecification type = new CilTypeSpecification();
type._typeSpecification = typeSpecification;
type._readers = readers;
type._isTypeInitialized = false;
return type;
}
public static TypeSpecification Combine(this TypeSpecification left, TypeSpecification right)
{
if (left == Any)
return right;
if (right == Any)
return left;
if (left == null || right == null)
return left ?? right;
return x =>
{
var leftOutcome = left(x);
return leftOutcome.WasSuccessful
? leftOutcome & right(x)
: leftOutcome;
};
}
private static MemberReference ElementTypeFor(TypeSpecification genericInstanceType)
{
return(genericInstanceType.ElementType);
}
public static TypeSpecification IsGenericArgument(this TypeSpecification @this)
{
Guard.NotNull(@this, "this");
return(@this.Combine(t => Outcome.FailIf(!t.IsGenericParameter, "Was not a generic argument.")));
}
private TypeSpecification Fix(TypeSpecification type, IGenericParameterProvider context)
{
var fet = Fix(type.ElementType, context);
if (type is ArrayType)
{
var array = (ArrayType)type;
var imported_array = new ArrayType(fet);
if (array.IsVector)
{
return(imported_array);
}
var dimensions = array.Dimensions;
var imported_dimensions = imported_array.Dimensions;
imported_dimensions.Clear();
for (int i = 0; i < dimensions.Count; i++)
{
var dimension = dimensions[i];
imported_dimensions.Add(new ArrayDimension(dimension.LowerBound, dimension.UpperBound));
}
return(imported_array);
}
if (type is PointerType)
{
return(new PointerType(fet));
}
if (type is ByReferenceType)
{
return(new ByReferenceType(fet));
}
if (type is PinnedType)
{
return(new PinnedType(fet));
}
if (type is SentinelType)
{
return(new SentinelType(fet));
}
if (type is OptionalModifierType)
{
TypeReference fmt = Fix(((OptionalModifierType)type).ModifierType, context);
return(new OptionalModifierType(fmt, fet));
}
if (type is RequiredModifierType)
{
TypeReference fmt = Fix(((RequiredModifierType)type).ModifierType);
return(new RequiredModifierType(fmt, fet));
}
if (type is GenericInstanceType)
{
var instance = (GenericInstanceType)type;
var imported_instance = new GenericInstanceType(fet);
var arguments = instance.GenericArguments;
var imported_arguments = imported_instance.GenericArguments;
for (int i = 0; i < arguments.Count; i++)
{
imported_arguments.Add(Fix(arguments[i], context));
}
return(imported_instance);
}
// TODO: what about FunctionPointerType?
throw new InvalidOperationException();
}
internal static TypeReference ResolveType(TypeReference original, Mono.Collections.Generic.Collection <GenericParameter> parameters, Mono.Collections.Generic.Collection <TypeReference> arguments)
{
TypeSpecification spec = original as TypeSpecification;
ArrayType array = original as ArrayType;
ByReferenceType reference = original as ByReferenceType;
GenericInstanceType genericType = original as GenericInstanceType;
if (parameters.Count != arguments.Count)
{
throw new System.ArgumentException("Parameters and Arguments must have the same number of elements.");
}
if (spec != null)
{
TypeReference resolved = ResolveType(spec.ElementType, parameters, arguments);
if (genericType != null)
{
GenericInstanceType result = new GenericInstanceType(genericType.ElementType);
bool found;
for (int i = 0; i < genericType.ElementType.GenericParameters.Count; i++)
{
found = false;
for (int k = 0; k < parameters.Count; k++)
{
if (genericType.ElementType.GenericParameters [i].Name == parameters [k].Name)
{
found = true;
result.GenericArguments.Add(arguments [k]);
break;
}
}
if (!found)
{
result.GenericArguments.Add(genericType.ElementType.GenericParameters [i]);
}
}
return(result);
}
if (resolved == spec.ElementType)
{
return(spec);
}
if (array != null)
{
return(new ArrayType(resolved, array.Dimensions.Count));
}
else if (reference != null)
{
return(new ByReferenceType(resolved));
}
else
{
throw new System.NotImplementedException();
}
}
else
{
for (int i = 0; i < parameters.Count; i++)
{
if (parameters [i] == original)
{
return(arguments [i]);
}
}
return(original);
}
}
/// <summary>
/// Emit an arbitrary type specification.
/// </summary>
/// <param name="typeSpecHandle">Type specification handle</param>
/// <param name="namespaceQualified">When set to true, include namespace information</param>
private void EmitTypeSpecificationName(TypeSpecificationHandle typeSpecHandle, bool namespaceQualified)
{
TypeSpecification typeSpec = _metadataReader.GetTypeSpecification(typeSpecHandle);
EmitTypeName(typeSpec.Signature, namespaceQualified);
}
public String CsdlPropCollType(TypeSpecification ts)
{
return(String.Format("Collection({0})", CsdlPropType(ts)));
}
public override CILInstructionInstance Execute(CILInstructionInstance instructionInstance, CILProgramState state, CILProgramInstance programInstance, Stack <CILInstructionInstance> callStack)
{
var reflectedType = TypeSpecification.GetTypeSpecified(programInstance);
var reflectedMethod = (MethodBase)reflectedType.GetMethod(MethodName, GetMethodArgumentRuntimeTypes(programInstance).ToArray());
if (reflectedMethod == null && MethodName.Equals(".ctor") && ParentMethod.IsConstructor)
{
return(instructionInstance.GetNextInstructionInstance());
}
var methodArguments = new List <object>();
for (int i = 0; i < MethodArgumentTypes.Count; i++)
{
var argumentType = GetMethodArgumentRuntimeTypes(programInstance)[MethodArgumentTypes.Count - i - 1];
var argument = state.Stack.Pop();
var methodArgument = ConvertHelper.ConvertIfPossible(argument, argumentType);
methodArguments.Add(methodArgument);
}
methodArguments.Reverse();
object methodObject = null;
if (CallConvention.Instance)
{
methodObject = state.Stack.Pop();
if (methodObject is Guid)
{
var objectAddress = (Guid)methodObject;
methodObject = ParentMethod.GetLocalByAddress(objectAddress);
}
}
var methodObjectToCall = methodObject;
if (methodObjectToCall is CILClassInstance)
{
methodObjectToCall = (methodObjectToCall as CILClassInstance).BaseInstance;
}
if (methodObject is CILClassInstance)
{
var cilClass = (methodObject as CILClassInstance)._cilClass;
var cilMethod = cilClass.Methods.SingleOrDefault(m => m.MethodName == this.MethodName && CILantroType.CompareArgumentTypes(m.ArgumentTypes.Select(at => at.GetRuntimeType(programInstance)).ToArray(), this.GetMethodArgumentRuntimeTypes(programInstance).ToArray()));
while (cilClass != null && cilMethod == null)
{
cilClass = cilClass.ExtendsClass;
if (cilClass != null)
{
cilMethod = cilClass.Methods.SingleOrDefault(m => m.MethodName == this.MethodName && CILantroType.CompareArgumentTypes(m.ArgumentTypes.Select(at => at.GetRuntimeType(programInstance)).ToArray(), this.GetMethodArgumentRuntimeTypes(programInstance).ToArray()));
}
}
if (cilMethod != null)
{
var newMethodInfo = new CILantroMethodInfo(cilMethod, programInstance, cilMethod.ReturnType.GetRuntimeType(programInstance));
reflectedMethod = newMethodInfo;
}
}
if (reflectedMethod is CILantroMethodInfo)
{
callStack.Push(instructionInstance.GetNextInstructionInstance());
var cilantroMethodInfo = reflectedMethod as CILantroMethodInfo;
CILMethod methodToCall = null;
object obj = methodObject;
//object obj = null;
if (CallConvention.Instance)
{
//obj = state.Stack.Pop();
var cilClassInstance = obj as CILClassInstance;
var cilClass = cilClassInstance._cilClass;
while (cilClass != null)
{
var matchingMethod = cilClass.Methods.FirstOrDefault(m => m.MethodName.Equals(MethodName) && CILantroType.CompareArgumentTypes(GetMethodArgumentRuntimeTypes(programInstance).ToArray(), m.ArgumentTypes.Select(ct => ct.GetRuntimeType(programInstance)).ToArray()));
if (matchingMethod != null)
{
methodToCall = matchingMethod;
break;
}
cilClass = programInstance.Program.Classes.FirstOrDefault(c => c.ClassName.UniqueName == cilClass.Extends.UniqueName);
}
}
if (methodToCall == null)
{
methodToCall = cilantroMethodInfo.Method;
}
return(methodToCall.CreateInstance(obj, methodArguments.ToArray()).GetFirstInstructionInstance());
}
var methodResult = reflectedMethod.Invoke(methodObjectToCall, methodArguments.ToArray());
if (MethodReturnType.GetRuntimeType(programInstance) != typeof(void))
{
state.Stack.Push(methodResult);
}
return(instructionInstance.GetNextInstructionInstance());
}
public ITypeDefOrRef ImportType(TypeSpecification specification)
{
var table = _tableStreamBuffer.GetTable<TypeSpecification>();
var newSpecification = table.FirstOrDefault(x => _signatureComparer.MatchTypes(x, specification));
if (newSpecification == null)
{
newSpecification = new TypeSpecification(ImportTypeSignature(specification.Signature));
table.Add(newSpecification);
}
return newSpecification;
}
/// <summary>
/// Create a new TypeSpecification object.
/// </summary>
/// <param name="typeName">Initial value of TypeName.</param>
/// <param name="collation">Initial value of Collation.</param>
/// <param name="characterSet">Initial value of CharacterSet.</param>
/// <param name="isMultiSet">Initial value of IsMultiSet.</param>
public static TypeSpecification CreateTypeSpecification(string typeName, Collation collation, CharacterSet characterSet, bool isMultiSet)
{
TypeSpecification typeSpecification = new TypeSpecification();
typeSpecification.TypeName = typeName;
typeSpecification.Collation = global::System.Data.Objects.DataClasses.StructuralObject.VerifyComplexObjectIsNotNull(collation, "Collation");
typeSpecification.CharacterSet = global::System.Data.Objects.DataClasses.StructuralObject.VerifyComplexObjectIsNotNull(characterSet, "CharacterSet");
typeSpecification.IsMultiSet = isMultiSet;
return typeSpecification;
}
public override void Weave(AssemblyDefinition assembly, MethodDefinition method)
{
ILProcessor ilProcessor = method.Body.GetILProcessor();
var objTracingInstructions = new List <Instruction>();
TypeSpecification referencedTypeSpec = null;
MetadataType paramMetaData;
TypeReference typeObject = assembly.MainModule.TypeSystem.Object;
bool pointerToValueTypeVariable = false;
int intMethodParamsCount = method.Parameters.Count;
int intArrayVarNumber = method.Body.Variables.Count;
ArrayType objArrType = new ArrayType(typeObject);
method.Body.Variables.Add(new VariableDefinition((TypeReference)objArrType));
method.Body.InitLocals = true;
//objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldstr,method.ToString()));
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldc_I4, intMethodParamsCount));
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Newarr, typeObject));
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Stloc, intArrayVarNumber));
// Loop over all the parameters of method and add their value to object[]
// ------------------------------------------------------------
for (int i = 0; i < intMethodParamsCount; i++)
{
paramMetaData = method.Parameters[i].ParameterType.MetadataType;
if (paramMetaData == MetadataType.UIntPtr ||
paramMetaData == MetadataType.FunctionPointer ||
paramMetaData == MetadataType.IntPtr ||
paramMetaData == MetadataType.Pointer)
{
// We don't want to log values of these parameters, so skip
// this iteration
break;
}
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldloc, intArrayVarNumber));
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldc_I4, i));
// Instance methods have an an implicit argument called "this"
// and hence, we need to refer to actual arguments with +1 position
// whereas, in case of static methods, "this" argument is not there
// ------------------------------------------------------------
if (method.IsStatic)
{
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldarg, i));
}
else
{
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldarg, i + 1));
}
// Reset boolean flag variable to false
pointerToValueTypeVariable = false;
// If aparameter is passed by reference then you need to use ldind
// ------------------------------------------------------------
TypeReference paramType = method.Parameters[i].ParameterType;
if (paramType.IsByReference)
{
referencedTypeSpec = paramType as TypeSpecification;
//Trace.WriteLine(string.Format("Parameter Name:{0}, Type:{1}", metDef.Parameters[i].Name, metDef.Parameters[i].ParameterType.Name));
if (referencedTypeSpec != null)
{
switch (referencedTypeSpec.ElementType.MetadataType)
{
//Indirect load value of type int8 as int32 on the stack
case MetadataType.Boolean:
case MetadataType.SByte:
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldind_I1));
pointerToValueTypeVariable = true;
break;
// Indirect load value of type int16 as int32 on the stack
case MetadataType.Int16:
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldind_I2));
pointerToValueTypeVariable = true;
break;
// Indirect load value of type int32 as int32 on the stack
case MetadataType.Int32:
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldind_I4));
pointerToValueTypeVariable = true;
break;
// Indirect load value of type int64 as int64 on the stack
// Indirect load value of type unsigned int64 as int64 on the stack (alias for ldind.i8)
case MetadataType.Int64:
case MetadataType.UInt64:
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldind_I8));
pointerToValueTypeVariable = true;
break;
// Indirect load value of type unsigned int8 as int32 on the stack
case MetadataType.Byte:
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldind_U1));
pointerToValueTypeVariable = true;
break;
// Indirect load value of type unsigned int16 as int32 on the stack
case MetadataType.UInt16:
case MetadataType.Char:
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldind_U2));
pointerToValueTypeVariable = true;
break;
// Indirect load value of type unsigned int32 as int32 on the stack
case MetadataType.UInt32:
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldind_U4));
pointerToValueTypeVariable = true;
break;
// Indirect load value of type float32 as F on the stack
case MetadataType.Single:
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldind_R4));
pointerToValueTypeVariable = true;
break;
// Indirect load value of type float64 as F on the stack
case MetadataType.Double:
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldind_R8));
pointerToValueTypeVariable = true;
break;
// Indirect load value of type native int as native int on the stack
case MetadataType.IntPtr:
case MetadataType.UIntPtr:
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldind_I));
pointerToValueTypeVariable = true;
break;
default:
// Need to check if it is a value type instance, in which case
// we use ldobj instruction to copy the contents of value type
// instance to stack and then box it
if (referencedTypeSpec.ElementType.IsValueType)
{
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldobj, referencedTypeSpec.ElementType));
pointerToValueTypeVariable = true;
}
else
{
// It is a reference type so just use reference the pointer
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldind_Ref));
pointerToValueTypeVariable = false;
}
break;
}
}
else
{
// We dont have complete details about the type of referenced parameter
// So we will just ignore this parameter value
}
}
// If it is a value type then you need to box the instance as we are going
// to add it to an array which is of type object (reference type)
// ------------------------------------------------------------
if (paramType.IsValueType || pointerToValueTypeVariable)
{
if (pointerToValueTypeVariable)
{
// Box the dereferenced parameter type
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Box, referencedTypeSpec.ElementType));
}
else
{
// Box the parameter type
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Box, paramType));
}
}
// Store parameter in object[] array
// ------------------------------------------------------------
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Stelem_Ref));
}
// Load address of array variable on evaluation stack, to pass
// it as a paremter
// ------------------------------------------------------------
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldloc, tracerIndex));
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Ldloc, intArrayVarNumber));
if (this.Parameters.DecodeParameters)
{
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Callvirt, WeaverUtil.ImportMethod <ItemTracer>(assembly, "SetParametersWithDecode")));
}
else
{
objTracingInstructions.Add(ilProcessor.Create(OpCodes.Callvirt, WeaverUtil.ImportMethod <ItemTracer>(assembly, "SetParameters")));
}
for (var i = objTracingInstructions.Count - 1; i >= 0; i--)
{
ilProcessor.InsertAfter(lastInstruction, objTracingInstructions[i]);
}
}
private static string GetPatchFullName(this ICustomAttributeProvider cap, MemberReference mr)
{
if (cap is TypeReference)
{
TypeReference type = (TypeReference)cap;
string name = cap.GetPatchName();
if (name.StartsWith("global::"))
{
name = name.Substring(8); // Patch name is refering to a global type.
}
else if (name.Contains(".") || name.Contains("/"))
{
} // Patch name is already a full name.
else if (!string.IsNullOrEmpty(type.Namespace))
{
name = $"{type.Namespace}.{name}";
}
else if (type.IsNested)
{
name = $"{type.DeclaringType.GetPatchFullName()}/{name}";
}
if (mr is TypeSpecification)
{
Stack <string> formats = new Stack <string>();
TypeSpecification ts = (TypeSpecification)mr;
do
{
if (ts.IsByReference)
{
formats.Push("{0}&");
}
else if (ts.IsPointer)
{
formats.Push("{0}*");
}
else if (ts.IsPinned)
{
} // FullName not overriden.
else if (ts.IsArray)
{
ArrayType array = (ArrayType)ts;
if (array.IsVector)
{
formats.Push("{0}[]");
}
else
{
StringBuilder format = new StringBuilder();
format.Append("{0}[");
for (int i = 0; i < array.Dimensions.Count; i++)
{
if (i > 0)
{
format.Append(",");
}
format.Append(array.Dimensions[i].ToString());
}
format.Append("]");
formats.Push(format.ToString());
}
}
else if (ts.IsRequiredModifier)
{
formats.Push($"{{0}} modreq({((RequiredModifierType) ts).ModifierType}");
}
else if (ts.IsOptionalModifier)
{
formats.Push($"{{0}} modopt({((OptionalModifierType) ts).ModifierType}");
}
else if (ts.IsGenericInstance)
{
GenericInstanceType gen = (GenericInstanceType)ts;
StringBuilder format = new StringBuilder();
format.Append("{0}<");
for (int i = 0; i < gen.GenericArguments.Count; i++)
{
if (i > 0)
{
format.Append(",");
}
format.Append(gen.GenericArguments[i].GetPatchFullName());
}
format.Append(">");
formats.Push(format.ToString());
}
else if (ts.IsFunctionPointer)
{
FunctionPointerType fpt = (FunctionPointerType)ts;
StringBuilder format = new StringBuilder();
format.Append("{0} ");
format.Append(fpt.ReturnType.GetPatchFullName());
format.Append(" *(");
if (fpt.HasParameters)
{
for (int i = 0; i < fpt.Parameters.Count; i++)
{
var parameter = fpt.Parameters[i];
if (i > 0)
{
format.Append(",");
}
if (parameter.ParameterType.IsSentinel)
{
format.Append("...,");
}
format.Append(parameter.ParameterType.FullName);
}
}
format.Append(")");
formats.Push(format.ToString());
}
else
{
throw new InvalidOperationException($"MonoMod can't handle TypeSpecification: {type.FullName} ({type.GetType()})");
}
} while ((ts = (ts.ElementType as TypeSpecification)) != null);
foreach (string format in formats)
{
name = string.Format(format, name);
}
}
return(name);
}
if (cap is FieldReference)
{
FieldReference field = (FieldReference)cap;
return($"{field.FieldType.GetPatchFullName()} {field.DeclaringType.GetPatchFullName()}::{cap.GetPatchName()}");
}
if (cap is MethodReference)
{
throw new InvalidOperationException("GetPatchFullName not supported on MethodReferences - use GetFindableID instead");
}
throw new InvalidOperationException($"GetPatchFullName not supported on type {cap.GetType()}");
}
static void WriteTypeReference(StringBuilder sb, TypeReference typeRef, bool isGenericInstance, bool full)
{
if (typeRef is TypeSpecification)
{
TypeSpecification typeSpec = typeRef as TypeSpecification;
if (typeSpec is ArrayType)
{
WriteTypeReference(sb, typeSpec.ElementType, full);
sb.Append("[");
var dims = (typeSpec as ArrayType).Dimensions;
for (int i = 0; i < dims.Count; i++)
{
if (i != 0)
{
sb.Append(", ");
}
if (dims[i].IsSized)
{
sb.Append(dims[i].LowerBound.HasValue ?
dims[i].LowerBound.ToString() : ".");
sb.Append("..");
sb.Append(dims[i].UpperBound.HasValue ?
dims[i].UpperBound.ToString() : ".");
}
}
sb.Append("]");
}
else if (typeSpec is ByReferenceType)
{
WriteTypeReference(sb, typeSpec.ElementType, full);
sb.Append("&");
}
else if (typeSpec is PointerType)
{
WriteTypeReference(sb, typeSpec.ElementType, full);
sb.Append("*");
}
else if (typeSpec is OptionalModifierType)
{
WriteTypeReference(sb, typeSpec.ElementType, full);
sb.Append(" ");
sb.Append("modopt");
sb.Append("(");
WriteTypeReference(sb, (typeSpec as OptionalModifierType).ModifierType, full);
sb.Append(")");
}
else if (typeSpec is RequiredModifierType)
{
WriteTypeReference(sb, typeSpec.ElementType, full);
sb.Append(" ");
sb.Append("modreq");
sb.Append("(");
WriteTypeReference(sb, (typeSpec as RequiredModifierType).ModifierType, full);
sb.Append(")");
}
else if (typeSpec is FunctionPointerType)
{
FunctionPointerType funcPtr = typeSpec as FunctionPointerType;
WriteTypeReference(sb, funcPtr.ReturnType, full);
sb.Append(" *(");
for (int i = 0; i < funcPtr.Parameters.Count; i++)
{
if (i != 0)
{
sb.Append(", ");
}
WriteTypeReference(sb, funcPtr.Parameters[i].ParameterType, full);
}
sb.Append(")");
}
else if (typeSpec is SentinelType)
{
sb.Append("...");
}
else if (typeSpec is GenericInstanceType)
{
WriteTypeReference(sb, typeSpec.ElementType, true);
sb.Append("<");
var args = (typeSpec as GenericInstanceType).GenericArguments;
for (int i = 0; i < args.Count; i++)
{
if (i != 0)
{
sb.Append(", ");
}
WriteTypeReference(sb, args[i], full);
}
sb.Append(">");
}
}
else if (typeRef is GenericParameter)
{
sb.Append((typeRef as GenericParameter).Name);
}
else
{
string name = typeRef.Name;
var genParamsCount = 0;
if (typeRef.HasGenericParameters)
{
genParamsCount = typeRef.GenericParameters.Count - (typeRef.DeclaringType == null ? 0 : typeRef.DeclaringType.GenericParameters.Count);
string str = "`" + genParamsCount.ToString();
if (typeRef.Name.EndsWith(str))
{
name = typeRef.Name.Substring(0, typeRef.Name.Length - str.Length);
}
}
if (typeRef.IsNested)
{
WriteTypeReference(sb, typeRef.DeclaringType, full);
sb.Append(".");
sb.Append(name);
}
else
{
if (full)
{
sb.Append(typeRef.Namespace);
if (!string.IsNullOrEmpty(typeRef.Namespace))
{
sb.Append(".");
}
}
sb.Append(name);
}
if (typeRef.HasGenericParameters && genParamsCount != 0 && !isGenericInstance)
{
sb.Append("<");
for (int i = typeRef.GenericParameters.Count - genParamsCount; i < typeRef.GenericParameters.Count; i++)
{
if (i != 0)
{
sb.Append(", ");
}
WriteTypeReference(sb, typeRef.GenericParameters[i], full);
}
sb.Append(">");
}
}
}
public TypeReference FixPlatformVersion(TypeReference reference)
{
if (targetPlatformDirectory == null)
{
return(reference);
}
AssemblyNameReference scopeAsm = reference.Scope as AssemblyNameReference;
if (scopeAsm != null)
{
AssemblyDefinition platformAsm = TryGetPlatformAssembly(scopeAsm);
if (platformAsm != null)
{
TypeReference newTypeRef;
if (reference is TypeSpecification)
{
TypeSpecification refSpec = reference as TypeSpecification;
TypeReference fet = FixPlatformVersion(refSpec.ElementType);
if (reference is ArrayType)
{
var array = (ArrayType)reference;
var imported_array = new ArrayType(fet);
if (array.IsVector)
{
return(imported_array);
}
var dimensions = array.Dimensions;
var imported_dimensions = imported_array.Dimensions;
imported_dimensions.Clear();
for (int i = 0; i < dimensions.Count; i++)
{
var dimension = dimensions[i];
imported_dimensions.Add(new ArrayDimension(dimension.LowerBound, dimension.UpperBound));
}
return(imported_array);
}
else if (reference is PointerType)
{
return(new PointerType(fet));
}
else if (reference is ByReferenceType)
{
return(new ByReferenceType(fet));
}
else if (reference is PinnedType)
{
return(new PinnedType(fet));
}
else if (reference is SentinelType)
{
return(new SentinelType(fet));
}
else if (reference is OptionalModifierType)
{
return(new OptionalModifierType(FixPlatformVersion(((OptionalModifierType)reference).ModifierType), fet));
}
else if (reference is RequiredModifierType)
{
return(new RequiredModifierType(FixPlatformVersion(((RequiredModifierType)reference).ModifierType), fet));
}
else if (reference is GenericInstanceType)
{
var instance = (GenericInstanceType)reference;
var element_type = FixPlatformVersion(instance.ElementType);
var imported_instance = new GenericInstanceType(element_type);
var arguments = instance.GenericArguments;
var imported_arguments = imported_instance.GenericArguments;
for (int i = 0; i < arguments.Count; i++)
{
imported_arguments.Add(FixPlatformVersion(arguments[i]));
}
return(imported_instance);
}
else if (reference is FunctionPointerType)
{
throw new NotImplementedException();
}
else
{
throw new InvalidOperationException();
}
}
else
{
newTypeRef = new TypeReference(reference.Namespace, reference.Name, reference.Module,
platformAsm.Name);
}
foreach (var gp in reference.GenericParameters)
{
newTypeRef.GenericParameters.Add(FixPlatformVersion(gp, newTypeRef));
}
newTypeRef.IsValueType = reference.IsValueType;
if (reference.DeclaringType != null)
{
newTypeRef.DeclaringType = FixPlatformVersion(reference.DeclaringType);
}
return(newTypeRef);
}
}
return(reference);
}
private void UpdateTypeSpec(Workspace workspace, TypeSpecification typeSpec)
{
// TODO: serialize blob.
}
/// <summary>
/// Create a new Parameter object.
/// </summary>
/// <param name="id">Initial value of Id.</param>
/// <param name="name">Initial value of Name.</param>
/// <param name="ordinal">Initial value of Ordinal.</param>
/// <param name="parameterType">Initial value of ParameterType.</param>
public static Parameter CreateParameter(string id, string name, int ordinal, TypeSpecification parameterType)
{
Parameter parameter = new Parameter();
parameter.Id = id;
parameter.Name = name;
parameter.Ordinal = ordinal;
parameter.ParameterType = global::System.Data.Objects.DataClasses.StructuralObject.VerifyComplexObjectIsNotNull(parameterType, "ParameterType");
return parameter;
}
public static TypeReference Relink(this TypeReference type, Relinker relinker, IGenericParameterProvider context)
{
if (type == null)
{
return(null);
}
if (type is TypeSpecification)
{
TypeSpecification ts = (TypeSpecification)type;
TypeReference relinkedElem = ts.ElementType.Relink(relinker, context);
if (type.IsByReference)
{
return(new ByReferenceType(relinkedElem));
}
if (type.IsPointer)
{
return(new PointerType(relinkedElem));
}
if (type.IsPinned)
{
return(new PinnedType(relinkedElem));
}
if (type.IsArray)
{
return(new ArrayType(relinkedElem, ((ArrayType)type).Dimensions.Count));
}
if (type.IsRequiredModifier)
{
return(new RequiredModifierType(((RequiredModifierType)type).ModifierType.Relink(relinker, context), relinkedElem));
}
if (type.IsOptionalModifier)
{
return(new OptionalModifierType(((OptionalModifierType)type).ModifierType.Relink(relinker, context), relinkedElem));
}
if (type.IsGenericInstance)
{
GenericInstanceType git = new GenericInstanceType(relinkedElem);
foreach (TypeReference genArg in ((GenericInstanceType)type).GenericArguments)
{
git.GenericArguments.Add(genArg?.Relink(relinker, context));
}
return(git);
}
if (type.IsFunctionPointer)
{
FunctionPointerType fp = (FunctionPointerType)type;
fp.ReturnType = fp.ReturnType.Relink(relinker, context);
for (int i = 0; i < fp.Parameters.Count; i++)
{
fp.Parameters[i].ParameterType = fp.Parameters[i].ParameterType.Relink(relinker, context);
}
return(fp);
}
throw new InvalidOperationException($"MonoMod can't handle TypeSpecification: {type.FullName} ({type.GetType()})");
}
if (type.IsGenericParameter)
{
GenericParameter genParam = context.GetGenericParameter(((GenericParameter)type).Name);
for (int i = 0; i < genParam.Constraints.Count; i++)
{
if (!genParam.Constraints[i].IsGenericInstance) // That is somehow possible and causes a stack overflow.
{
genParam.Constraints[i] = genParam.Constraints[i].Relink(relinker, context);
}
}
return(genParam);
}
return((TypeReference)relinker(type, context));
}
/// <summary>
/// Create a new ScalarFunction object.
/// </summary>
/// <param name="id">Initial value of Id.</param>
/// <param name="name">Initial value of Name.</param>
/// <param name="returnType">Initial value of ReturnType.</param>
public static ScalarFunction CreateScalarFunction(string id, string name, TypeSpecification returnType)
{
ScalarFunction scalarFunction = new ScalarFunction();
scalarFunction.Id = id;
scalarFunction.Name = name;
scalarFunction.ReturnType = global::System.Data.Objects.DataClasses.StructuralObject.VerifyComplexObjectIsNotNull(returnType, "ReturnType");
return scalarFunction;
}
public String SsdlPropType(TypeSpecification ts)
{
return(ts.TypeName);
}
private string GetMonoEmbeddedFullTypeNameFor(TypeReference type)
{
TypeSpecification typeSpecification = type as TypeSpecification;
return((typeSpecification == null || !((TypeReference)typeSpecification).get_IsRequiredModifier() ? (!type.get_IsRequiredModifier() ? type.get_FullName() : type.GetElementType().get_FullName()) : typeSpecification.get_ElementType().get_FullName()).Replace('/', '+').Replace('<', '[').Replace('>', ']'));
}
/// <inheritdoc />
public int GetHashCode(TypeSpecification obj)
{
return(GetHashCode(obj.Signature));
}
public static TypeReference For(TypeReference byRefType)
{
TypeSpecification specification = byRefType as TypeSpecification;
return(specification?.ElementType);
}
private Instruction AddInterceptCall(ILProcessor ilProcessor, MethodDefinition methDef, MethodDefinition interceptMethDef, CustomAttribute att, Instruction insertBefore)
{
var methRef = _assemblyDefinition.MainModule.ImportReference(interceptMethDef);
ilProcessor.InsertBefore(insertBefore, ilProcessor.CreateLoadInstruction(methDef.Name));
int methodParamCount = methDef.Parameters.Count;
int arrayVarNr = methDef.Body.Variables.Count;
if (methodParamCount > 0)
{
ArrayType objArrType = new ArrayType(_assemblyDefinition.MainModule.TypeSystem.Object);
methDef.Body.Variables.Add(new VariableDefinition(objArrType));
methDef.Body.InitLocals = true;
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldc_I4, methodParamCount));
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Newarr, _assemblyDefinition.MainModule.TypeSystem.Object));
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Stloc, arrayVarNr));
bool pointerToValueTypeVariable;
TypeSpecification referencedTypeSpec = null;
for (int i = 0; i < methodParamCount; i++)
{
var paramMetaData = methDef.Parameters[i].ParameterType.MetadataType;
if (paramMetaData == MetadataType.UIntPtr || paramMetaData == MetadataType.FunctionPointer ||
paramMetaData == MetadataType.IntPtr || paramMetaData == MetadataType.Pointer)
{
break;
}
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldloc, arrayVarNr));
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldc_I4, i));
if (methDef.IsStatic)
{
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldarg, i));
}
else
{
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldarg, i + 1));
}
pointerToValueTypeVariable = false;
TypeReference paramType = methDef.Parameters[i].ParameterType;
if (paramType.IsByReference)
{
referencedTypeSpec = paramType as TypeSpecification;
if (referencedTypeSpec != null)
{
switch (referencedTypeSpec.ElementType.MetadataType)
{
case MetadataType.Boolean:
case MetadataType.SByte:
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldind_I1));
pointerToValueTypeVariable = true;
break;
case MetadataType.Int16:
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldind_I2));
pointerToValueTypeVariable = true;
break;
case MetadataType.Int32:
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldind_I4));
pointerToValueTypeVariable = true;
break;
case MetadataType.Int64:
case MetadataType.UInt64:
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldind_I8));
pointerToValueTypeVariable = true;
break;
case MetadataType.Byte:
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldind_U1));
pointerToValueTypeVariable = true;
break;
case MetadataType.UInt16:
case MetadataType.Char:
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldind_U2));
pointerToValueTypeVariable = true;
break;
case MetadataType.UInt32:
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldind_U4));
pointerToValueTypeVariable = true;
break;
case MetadataType.Single:
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldind_R4));
pointerToValueTypeVariable = true;
break;
case MetadataType.Double:
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldind_R8));
pointerToValueTypeVariable = true;
break;
case MetadataType.IntPtr:
case MetadataType.UIntPtr:
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldind_I));
pointerToValueTypeVariable = true;
break;
default:
if (referencedTypeSpec.ElementType.IsValueType)
{
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldobj, referencedTypeSpec.ElementType));
pointerToValueTypeVariable = true;
}
else
{
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldind_Ref));
pointerToValueTypeVariable = false;
}
break;
}
}
else
{
}
}
if (paramType.IsValueType || pointerToValueTypeVariable)
{
if (pointerToValueTypeVariable)
{
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Box, referencedTypeSpec.ElementType));
}
else
{
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Box, paramType));
}
}
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Stelem_Ref));
}
ilProcessor.InsertBefore(insertBefore, ilProcessor.Create(OpCodes.Ldloc, arrayVarNr));
}
var ins = ilProcessor.Create(OpCodes.Callvirt, methDef.Module.ImportReference(interceptMethDef));
ilProcessor.InsertBefore(insertBefore, ins);
return(ins);
}
protected override StringBuilder AppendRefTypeName(StringBuilder buf, TypeReference type, DynamicParserContext context)
{
TypeSpecification spec = type as TypeSpecification;
return(_AppendTypeName(buf, spec != null ? spec.ElementType : type.GetElementType(), context).Append(RefTypeModifier));
}
private static string GetFriendlyFullTypeSpecificationName(this TypeSpecification self, ILanguage language, bool includeNamespace = true)
{
return(self.ElementType.GetFriendlyFullName(language, includeNamespace));
}
static bool Match(TypeReference type, TypeReference target)
{
if (!(target is TypeSpecification))
{
return(type.Name == target.Name && type.Namespace == target.Namespace);
}
if (type.MetadataType != target.MetadataType)
{
return(false);
}
TypeSpecification typeSpecA = type as TypeSpecification;
TypeSpecification typeSpecB = target as TypeSpecification;
switch (type.MetadataType)
{
case MetadataType.Array:
{
ArrayType arrA = type as ArrayType, arrB = target as ArrayType;
if (arrA.Dimensions.Count != arrB.Dimensions.Count)
{
return(false);
}
for (int i = 0; i < arrA.Dimensions.Count; i++)
{
if (arrA.Dimensions[i].LowerBound != arrB.Dimensions[i].LowerBound ||
arrA.Dimensions[i].UpperBound != arrB.Dimensions[i].UpperBound)
{
return(false);
}
}
return(Match(typeSpecA.ElementType, typeSpecB.ElementType));
}
case MetadataType.RequiredModifier:
{
RequiredModifierType modA = type as RequiredModifierType, modB = target as RequiredModifierType;
return(Match(modA.ModifierType, modB.ModifierType) &&
Match(typeSpecA.ElementType, typeSpecB.ElementType));
}
case MetadataType.OptionalModifier:
{
OptionalModifierType modA = type as OptionalModifierType, modB = target as OptionalModifierType;
return(Match(modA.ModifierType, modB.ModifierType) &&
Match(typeSpecA.ElementType, typeSpecB.ElementType));
}
case MetadataType.ByReference:
case MetadataType.Pinned:
case MetadataType.Pointer:
return(Match(typeSpecA.ElementType, typeSpecB.ElementType));
case MetadataType.GenericInstance:
GenericInstanceType instA = type as GenericInstanceType, instB = target as GenericInstanceType;
if (instA.GenericArguments.Count != instB.GenericArguments.Count)
{
return(false);
}
for (int i = 0; i < instA.GenericArguments.Count; i++)
{
if (!Match(instA.GenericArguments[i], instB.GenericArguments[i]))
{
return(false);
}
}
return(Match(typeSpecA.ElementType, typeSpecB.ElementType));
case MetadataType.FunctionPointer: //not support
throw new NotSupportedException();
}
return(false);
}
public static TypeSpecificationSignature GetSignature(this MetadataReader metadataReader, TypeSpecification typeSpecification)
{
return(new TypeSpecificationSignature(metadataReader.GetBlobReader(typeSpecification.Signature)));
}
public override void Init(IScriptExportManager manager)
{
TypeSpecification specification = (TypeSpecification)Type;
m_element = manager.RetrieveType(specification.ElementType);
}
private static string GetFriendlyFullTypeSpecificationName(this TypeSpecification self, ILanguage language)
{
return(self.get_ElementType().GetFriendlyFullName(language));
}
/// <summary>
/// Defines the type of the output writer class that will handle
/// writing output of ResourceStaticAnalysis to external storage (such as XML file).
/// Assembly name will be guessed from the type information contained in <paramref name="outputWriterType"/>.
/// </summary>
/// <param name="outputWriterType">Type inheriting from IOutputWriter class. Must be instantiable.</param>
public void SetDataSourceProvider(Type outputWriterType)
{
Kind = TypeSpecification.CreateSpecification(outputWriterType.FullName, outputWriterType.Assembly.GetName().FullName);
}
public CustomAttributeValue <TType> DecodeValue(EntityHandle constructor, BlobHandle value)
{
BlobHandle signature;
BlobHandle attributeOwningTypeSpec = default;
switch (constructor.Kind)
{
case HandleKind.MethodDefinition:
MethodDefinition definition = _reader.GetMethodDefinition((MethodDefinitionHandle)constructor);
signature = definition.Signature;
break;
case HandleKind.MemberReference:
MemberReference reference = _reader.GetMemberReference((MemberReferenceHandle)constructor);
signature = reference.Signature;
// If this is a generic attribute, we'll need its instantiation to decode the signatures
if (reference.Parent.Kind == HandleKind.TypeSpecification)
{
TypeSpecification genericOwner = _reader.GetTypeSpecification((TypeSpecificationHandle)reference.Parent);
attributeOwningTypeSpec = genericOwner.Signature;
}
break;
default:
throw new BadImageFormatException();
}
BlobReader signatureReader = _reader.GetBlobReader(signature);
BlobReader valueReader = _reader.GetBlobReader(value);
ushort prolog = valueReader.ReadUInt16();
if (prolog != 1)
{
throw new BadImageFormatException();
}
SignatureHeader header = signatureReader.ReadSignatureHeader();
if (header.Kind != SignatureKind.Method || header.IsGeneric)
{
throw new BadImageFormatException();
}
int parameterCount = signatureReader.ReadCompressedInteger();
SignatureTypeCode returnType = signatureReader.ReadSignatureTypeCode();
if (returnType != SignatureTypeCode.Void)
{
throw new BadImageFormatException();
}
BlobReader genericContextReader = default;
if (!attributeOwningTypeSpec.IsNil)
{
// If this is a generic attribute, grab the instantiation arguments so that we can
// interpret the constructor signature, should it refer to the generic context.
genericContextReader = _reader.GetBlobReader(attributeOwningTypeSpec);
if (genericContextReader.ReadSignatureTypeCode() == SignatureTypeCode.GenericTypeInstance)
{
int kind = genericContextReader.ReadCompressedInteger();
if (kind != (int)SignatureTypeKind.Class && kind != (int)SignatureTypeKind.ValueType)
{
throw new BadImageFormatException();
}
genericContextReader.ReadTypeHandle();
// At this point, the reader points to the "GenArgCount Type Type*" part of the signature.
}
else
{
// Some other invalid TypeSpec. Don't accidentally allow resolving generic parameters
// from the constructor signature into a broken blob.
genericContextReader = default;
}
}
ImmutableArray <CustomAttributeTypedArgument <TType> > fixedArguments = DecodeFixedArguments(ref signatureReader, ref valueReader, parameterCount, genericContextReader);
ImmutableArray <CustomAttributeNamedArgument <TType> > namedArguments = DecodeNamedArguments(ref valueReader);
return(new CustomAttributeValue <TType>(fixedArguments, namedArguments));
}
private IEnumerable<TypeSpecification> OnGetImplementations(TypeSpecification typeSpecification)
{
Argument.IsNotNull(() => typeSpecification);
var result = new List<TypeSpecification>();
foreach (var node in Assemblies)
{
result.AddRange(node.GetImplementations(typeSpecification.FullName).Cast<TypeSpecification>());
}
return result;
}
public TypeSpecificationType(GenericContext gc, TypeSpecificationHandle handle) : base(gc.cx)
{
ts = cx.mdReader.GetTypeSpecification(handle);
decodedType = ts.DecodeSignature(cx.TypeSignatureDecoder, gc);
ShortId = decodedType.ShortId;
}
partial void OnColumnTypeChanging(TypeSpecification value);
public TypeSpecificationImporter(TypeSpecification type, MemberImportingSession session)
: base(type, session)
{
}
partial void OnParameterTypeChanging(TypeSpecification value);
public static string ToString(this MetadataReader reader, TypeSpecification x) => $"{{TypeSpec[{RowId(x):X}]: {reader.TypeSignatureToString(x.Signature)}}}";
partial void OnReturnTypeChanging(TypeSpecification value);
private TypeSpecification Fix(TypeSpecification type)
{
var fet = Fix(type.ElementType);
if (type is ArrayType)
{
var array = (ArrayType)type;
var imported_array = new ArrayType(fet);
if (array.IsVector)
{
return(imported_array);
}
var dimensions = array.Dimensions;
var imported_dimensions = imported_array.Dimensions;
imported_dimensions.Clear();
for (int i = 0; i < dimensions.Count; i++)
{
var dimension = dimensions[i];
imported_dimensions.Add(new ArrayDimension(dimension.LowerBound, dimension.UpperBound));
}
return(imported_array);
}
if (type is PointerType)
{
return(new PointerType(fet));
}
if (type is ByReferenceType)
{
return(new ByReferenceType(fet));
}
if (type is PinnedType)
{
return(new PinnedType(fet));
}
if (type is SentinelType)
{
return(new SentinelType(fet));
}
if (type is OptionalModifierType)
{
TypeReference fmt = Fix(((OptionalModifierType)type).ModifierType);
return(new OptionalModifierType(fmt, fet));
}
if (type is RequiredModifierType)
{
TypeReference fmt = Fix(((RequiredModifierType)type).ModifierType);
return(new RequiredModifierType(fmt, fet));
}
if (type is GenericInstanceType)
{
var instance = (GenericInstanceType)type;
var imported_instance = new GenericInstanceType(fet);
var arguments = instance.GenericArguments;
var imported_arguments = imported_instance.GenericArguments;
for (int i = 0; i < arguments.Count; i++)
{
imported_arguments.Add(Fix(arguments[i]));
}
return(imported_instance);
}
if (type is FunctionPointerType)
{
var funcPtr = (FunctionPointerType)type;
var imported_instance = new FunctionPointerType()
{
HasThis = funcPtr.HasThis,
ExplicitThis = funcPtr.ExplicitThis,
CallingConvention = funcPtr.CallingConvention,
ReturnType = Fix(funcPtr.ReturnType)
};
if (funcPtr.HasParameters)
{
foreach (var pd in funcPtr.Parameters)
{
imported_instance.Parameters.Add(pd);
}
FixReferences(imported_instance.Parameters);
}
return(imported_instance);
}
throw new InvalidOperationException();
}
/// <summary>
/// Create a new Column object.
/// </summary>
/// <param name="id">Initial value of Id.</param>
/// <param name="name">Initial value of Name.</param>
/// <param name="ordinal">Initial value of Ordinal.</param>
/// <param name="isNullable">Initial value of IsNullable.</param>
/// <param name="columnType">Initial value of ColumnType.</param>
/// <param name="isIdentity">Initial value of IsIdentity.</param>
/// <param name="isStoreGenerated">Initial value of IsStoreGenerated.</param>
public static Column CreateColumn(string id, string name, int ordinal, bool isNullable, TypeSpecification columnType, bool isIdentity, bool isStoreGenerated)
{
Column column = new Column();
column.Id = id;
column.Name = name;
column.Ordinal = ordinal;
column.IsNullable = isNullable;
column.ColumnType = global::System.Data.Objects.DataClasses.StructuralObject.VerifyComplexObjectIsNotNull(columnType, "ColumnType");
column.IsIdentity = isIdentity;
column.IsStoreGenerated = isStoreGenerated;
return column;
}
static bool AreSame (TypeSpecification a, TypeSpecification b)
{
if (!AreSame (a.ElementType, b.ElementType))
return false;
if (a.IsGenericInstance)
return AreSame ((GenericInstanceType) a, (GenericInstanceType) b);
if (a.IsRequiredModifier || a.IsOptionalModifier)
return AreSame ((IModifierType) a, (IModifierType) b);
if (a.IsArray)
return AreSame ((ArrayType) a, (ArrayType) b);
return true;
}
