/// <summary> /// Allocates a reference to a method. /// </summary> /// <param name="host">Provides a standard abstraction over the applications that host components that provide or consume objects from the metadata model.</param> /// <param name="containingType">A reference to the containing type of the referenced method.</param> /// <param name="callingConvention">The calling convention of the referenced method.</param> /// <param name="returnType">The return type of the referenced method.</param> /// <param name="name">The name of the referenced method.</param> /// <param name="genericParameterCount">The number of generic parameters of the referenced method. Zero if the referenced method is not generic.</param> /// <param name="parameters">Information about the parameters forming part of the signature of the referenced method.</param> /// <param name="extraParameterTypes">Reference to the types of the the extra arguments supplied by the method call that uses this reference.</param> public MethodReference(IMetadataHost host, ITypeReference containingType, CallingConvention callingConvention, ITypeReference returnType, IName name, ushort genericParameterCount, IEnumerable <IParameterTypeInformation> parameters, params ITypeReference[] extraParameterTypes) { this.host = host; _containingType = containingType; _callingConvention = callingConvention; _type = returnType; _name = name; _genericParameterCount = genericParameterCount; _parameters = parameters; _parameterCount = (ushort)IteratorHelper.EnumerableCount(parameters); List <IParameterTypeInformation> extraParameters = new List <IParameterTypeInformation>(extraParameterTypes.Length); for (ushort i = 0; i < extraParameterTypes.Length; i++) { extraParameters.Add(new SimpleParameterTypeInformation(this, i, extraParameterTypes[i])); } _extraParameters = extraParameters.AsReadOnly(); }
/// <summary> /// Returns true if the two signatures match according to the criteria of the CLR loader. /// </summary> public static bool SignaturesAreEqual(ISignature signature1, ISignature signature2) { if (signature1.CallingConvention != signature2.CallingConvention) { return(false); } if (signature1.ReturnValueIsByRef != signature2.ReturnValueIsByRef) { return(false); } if (signature1.ReturnValueIsModified != signature2.ReturnValueIsModified) { return(false); } if (!TypeHelper.TypesAreEquivalent(signature1.Type, signature2.Type)) { return(false); } return(IteratorHelper.EnumerablesAreEqual(signature1.Parameters, signature2.Parameters, ParameterInformationComparer)); }
/// <summary> /// Computes the string representing the strong name of the given assembly reference. /// </summary> public static string StrongName(IAssemblyReference assemblyReference) { Contract.Requires(assemblyReference != null); Contract.Ensures(Contract.Result <string>() != null); StringBuilder sb = StringBuilderCache.Acquire(); sb.AppendQuoted(assemblyReference.Name.Value); sb.AppendFormat(CultureInfo.InvariantCulture, ", Version={0}.{1}.{2}.{3}", assemblyReference.Version.Major, assemblyReference.Version.Minor, assemblyReference.Version.Build, assemblyReference.Version.Revision); if (assemblyReference.Culture.Length > 0) { sb.AppendFormat(CultureInfo.InvariantCulture, ", Culture="); sb.AppendQuoted(assemblyReference.Culture); } else { sb.Append(", Culture=neutral"); } sb.AppendFormat(CultureInfo.InvariantCulture, ", PublicKeyToken="); if (IteratorHelper.EnumerableIsNotEmpty(assemblyReference.PublicKeyToken)) { foreach (byte b in assemblyReference.PublicKeyToken) { sb.Append(b.ToString("x2", CultureInfo.InvariantCulture)); } } else { sb.Append("null"); } if (assemblyReference.IsRetargetable) { sb.Append(", Retargetable=Yes"); } if (assemblyReference.ContainsForeignTypes) { sb.Append(", ContentType=WindowsRuntime"); } return(StringBuilderCache.GetStringAndRelease(sb)); }
/// <summary> /// Returns true if the given object is an identifier that identifies the same object as this identifier. /// </summary> //^ [Confined] public sealed override bool Equals(object /*?*/ obj) { if (obj == (object)this) { return(true); } AssemblyIdentity /*?*/ otherAssembly = obj as AssemblyIdentity; if (otherAssembly == null) { return(false); } if (this.Name.UniqueKeyIgnoringCase != otherAssembly.Name.UniqueKeyIgnoringCase) { return(false); } if (this.Version != otherAssembly.Version) { return(false); } if (string.Compare(this.Culture, otherAssembly.Culture, StringComparison.OrdinalIgnoreCase) != 0) { return(false); } if (IteratorHelper.EnumerableIsNotEmpty(this.PublicKeyToken)) { return(IteratorHelper.EnumerablesAreEqual(this.PublicKeyToken, otherAssembly.PublicKeyToken)); } else { if (this.Location.Length == 0 || otherAssembly.Location.Length == 0) { return(true); } return(string.Compare(this.Location, otherAssembly.Location, StringComparison.OrdinalIgnoreCase) == 0); } }
/// <summary> /// Returns true if the given object is an identifier that identifies the same object as this identifier. /// </summary> //^ [Confined] public sealed override bool Equals(object /*?*/ obj) { if (obj == (object)this) { return(true); } AssemblyIdentity /*?*/ otherAssembly = obj as AssemblyIdentity; if (otherAssembly == null) { return(false); } if (this.Name.UniqueKeyIgnoringCase != otherAssembly.Name.UniqueKeyIgnoringCase) { return(false); } if (this.Version != otherAssembly.Version) { return(false); } if (string.Compare(this.Culture, otherAssembly.Culture, StringComparison.OrdinalIgnoreCase) != 0) { return(false); } if (IteratorHelper.EnumerableIsNotEmpty(this.PublicKeyToken)) { return(IteratorHelper.EnumerablesAreEqual(this.PublicKeyToken, otherAssembly.PublicKeyToken)); } else { // This can be dangerous! Returning true here means that weakly named assemblies are assumed to be the // same just because their name is the same. So two assemblies from different locations but the same name // should *NOT* be allowed. return(true); } }
/// <summary> /// Returns true if the given two assembly references are to be considered equivalent. /// </summary> public static bool AssembliesAreEquivalent(IAssemblyReference /*?*/ assembly1, IAssemblyReference /*?*/ assembly2) { if (assembly1 == null || assembly2 == null) { return(false); } if (assembly1 == assembly2) { return(true); } if (assembly1.Name.UniqueKeyIgnoringCase != assembly2.Name.UniqueKeyIgnoringCase) { return(false); } if (!assembly1.Version.Equals(assembly2.Version)) { return(false); } if (!assembly1.Culture.Equals(assembly2.Culture)) { return(false); } return(IteratorHelper.EnumerablesAreEqual <byte>(assembly1.PublicKeyToken, assembly2.PublicKeyToken)); }
/// <summary> /// Return zero or more locations in primary source documents that correspond to the definition of the given local. /// </summary> public IEnumerable <IPrimarySourceLocation> GetPrimarySourceLocationsForDefinitionOf(ILocalDefinition localDefinition) { PdbFunction /*?*/ pdbFunction = this.GetPdbFunctionFor(localDefinition); if (pdbFunction != null) { uint index = 0; foreach (ILocation location in localDefinition.Locations) { IILLocation /*?*/ mbLocation = location as IILLocation; if (mbLocation != null) { index = mbLocation.Offset; break; } } PdbSlot /*?*/ slot = this.GetSlotFor(pdbFunction.scopes, index); if (slot != null && (slot.flags & 0x4) == 0) { return(IteratorHelper.GetSingletonEnumerable <IPrimarySourceLocation>(new LocalNameSourceLocation(slot.name))); } } return(Enumerable <IPrimarySourceLocation> .Empty); }
public IEnumerable <INamedTypeDefinition> GetAllTypes() { return(IteratorHelper.GetEmptyEnumerable <INamedTypeDefinition>()); }
public IEnumerable <ITypeDefinitionMember> GetMatchingMembers(Function <ITypeDefinitionMember, bool> predicate) { return(IteratorHelper.GetEmptyEnumerable <ITypeDefinitionMember>()); }
public IEnumerable <ITypeDefinitionMember> GetMembersNamed(IName name, bool ignoreCase) { return(IteratorHelper.GetEmptyEnumerable <ITypeDefinitionMember>()); }
/// <summary> /// Return zero or more locations in primary source documents that correspond to the definition of the given local. /// </summary> public virtual IEnumerable <IPrimarySourceLocation> GetPrimarySourceLocationsForDefinitionOf(ILocalDefinition localDefinition) { return(IteratorHelper.GetEmptyEnumerable <IPrimarySourceLocation>()); }
public IEnumerable <ITypeDefinitionMember> GetMatchingMembersNamed(IName name, bool ignoreCase, Function <ITypeDefinitionMember, bool> predicate) { return(IteratorHelper.GetEmptyEnumerable <ITypeDefinitionMember>()); }
/// <summary> /// Returns zero or more local (block) scopes, each defining an IL range in which an iterator local is defined. /// The scopes are returned by the MoveNext method of the object returned by the iterator method. /// The index of the scope corresponds to the index of the local. Specifically local scope i corresponds /// to the local stored in field <localName>x_i of the class used to store the local values in between /// calls to MoveNext. /// </summary> public virtual IEnumerable <ILocalScope> GetIteratorScopes(IMethodBody methodBody) { return(IteratorHelper.GetEmptyEnumerable <ILocalScope>()); }
/// <summary> /// Returns zero or more local constant definitions that are local to the given scope. /// </summary> public virtual IEnumerable <ILocalDefinition> GetConstantsInScope(ILocalScope scope) { return(IteratorHelper.GetEmptyEnumerable <ILocalDefinition>()); }
/// <summary> /// Creation helper from IEnumerable{T} /// </summary> public static ReadOnlyList <T> Create(IEnumerable <T> list) { return(Create(IteratorHelper.EnumerableCount <T>(list))); }
/// <summary> /// Returns a sequence of descriptors that define where try blocks and their associated handlers can be found in the instruction sequence. /// </summary> public IEnumerable <IOperationExceptionInformation> GetOperationExceptionInformation() { return(IteratorHelper.GetConversionEnumerable <ExceptionHandler, IOperationExceptionInformation>(this.handlers)); }
public IEnumerable <string> GetStrings() { return(IteratorHelper.GetEmptyEnumerable <string>()); }
/// <summary> /// Returns the number of least significant bits in the representation of field.Type that should be ignored when reading or writing the field value at MemberHelper.GetFieldOffset(field). /// </summary> /// <param name="field">The bit field whose bit offset is to returned.</param> public static uint GetFieldBitOffset(IFieldDefinition field) //^ requires field.IsBitField; { ITypeDefinition typeDefinition = field.ContainingTypeDefinition; uint result = 0; ushort bitFieldAlignment = 0; uint bitOffset = 0; IEnumerable <ITypeDefinitionMember> members = typeDefinition.Members; if (typeDefinition.Layout == LayoutKind.Sequential) { List <IFieldDefinition> fields = new List <IFieldDefinition>(IteratorHelper.GetFilterEnumerable <ITypeDefinitionMember, IFieldDefinition>(members)); fields.Sort(delegate(IFieldDefinition f1, IFieldDefinition f2) { return(f1.SequenceNumber - f2.SequenceNumber); }); members = IteratorHelper.GetConversionEnumerable <IFieldDefinition, ITypeDefinitionMember>(fields); } foreach (ITypeDefinitionMember member in members) { IFieldDefinition /*?*/ f = member as IFieldDefinition; if (f == null || f.IsStatic) { continue; } ushort fieldAlignment = (ushort)(TypeHelper.TypeAlignment(f.Type.ResolvedType) * 8); if (f == field) { if (f.IsBitField) { if (bitOffset > 0 && bitOffset + f.BitLength > bitFieldAlignment) { bitOffset = 0; } return(bitOffset); } return(0); } uint fieldSize; if (f.IsBitField) { bitFieldAlignment = fieldAlignment; fieldSize = f.BitLength; if (bitOffset > 0 && bitOffset + fieldSize > fieldAlignment) { bitOffset = 0; } if (bitOffset == 0 || fieldSize == 0) { result = ((result + fieldAlignment - 1) / fieldAlignment) * fieldAlignment; bitOffset = 0; } bitOffset += fieldSize; } else { if (bitFieldAlignment > fieldAlignment) { fieldAlignment = bitFieldAlignment; } bitFieldAlignment = 0; bitOffset = 0; result = ((result + fieldAlignment - 1) / fieldAlignment) * fieldAlignment; fieldSize = TypeHelper.SizeOfType(f.Type.ResolvedType) * 8; } result += fieldSize; } //^ assume false; //TODO: eventually prove this. return(0); }
/// <summary> /// Returns the number of bytes that separate the start of an instance of the items's declaring type from the start of the field itself. /// </summary> /// <param name="item">The item (field or nested type) of interests, which must not be static. </param> /// <param name="containingTypeDefinition">The type containing the item.</param> /// <returns></returns> public static uint ComputeFieldOffset(ITypeDefinitionMember item, ITypeDefinition containingTypeDefinition) //^ requires !field.IsStatic; { uint result = 0; ushort bitFieldAlignment = 0; uint bitOffset = 0; IEnumerable <ITypeDefinitionMember> members = containingTypeDefinition.Members; if (containingTypeDefinition.Layout == LayoutKind.Sequential) { List <IFieldDefinition> fields = new List <IFieldDefinition>(IteratorHelper.GetFilterEnumerable <ITypeDefinitionMember, IFieldDefinition>(members)); fields.Sort(delegate(IFieldDefinition f1, IFieldDefinition f2) { return(f1.SequenceNumber - f2.SequenceNumber); }); members = IteratorHelper.GetConversionEnumerable <IFieldDefinition, ITypeDefinitionMember>(fields); } foreach (ITypeDefinitionMember member in members) { INestedTypeDefinition fieldAsTypeDef = member as INestedTypeDefinition; if (fieldAsTypeDef != null && fieldAsTypeDef == item) { ushort typeAlignment = (ushort)(TypeHelper.TypeAlignment(fieldAsTypeDef.ResolvedType) * 8); return((((result + typeAlignment - 1) / typeAlignment) * typeAlignment) / 8); } else { IFieldDefinition /*?*/ f = member as IFieldDefinition; if (f == null || f.IsStatic) { continue; } if (f.Type.ResolvedType == item) { continue; // in case we are calculating the offset of an anonymous type, skip the implicit field of that type } ushort fieldAlignment = (ushort)(TypeHelper.TypeAlignment(f.Type.ResolvedType) * 8); if (f == item) { if (f.IsBitField && bitOffset > 0 && bitOffset + f.BitLength <= bitFieldAlignment) { return((result - bitOffset) / 8); } if (bitFieldAlignment > fieldAlignment) { fieldAlignment = bitFieldAlignment; } return((((result + fieldAlignment - 1) / fieldAlignment) * fieldAlignment) / 8); } uint fieldSize; if (f.IsBitField) { bitFieldAlignment = fieldAlignment; fieldSize = f.BitLength; if (bitOffset > 0 && bitOffset + fieldSize > fieldAlignment) { bitOffset = 0; } if (bitOffset == 0 || fieldSize == 0) { result = ((result + fieldAlignment - 1) / fieldAlignment) * fieldAlignment; bitOffset = 0; } bitOffset += fieldSize; } else { if (bitFieldAlignment > fieldAlignment) { fieldAlignment = bitFieldAlignment; } bitFieldAlignment = 0; bitOffset = 0; result = ((result + fieldAlignment - 1) / fieldAlignment) * fieldAlignment; fieldSize = TypeHelper.SizeOfType(f.Type.ResolvedType) * 8; } result += fieldSize; } } return(0); }