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