private LowLevelDictionary<string, QHandle> CreateCaseInsensitiveTypeDictionary() { // // Collect all of the *non-nested* types and type-forwards. // // The keys are full typenames in lower-cased form. // The value is a tuple containing either a TypeDefinitionHandle or TypeForwarderHandle and the associated Reader // for that handle. // // We do not store nested types here. The container type is resolved and chosen first, then the nested type chosen from // that. If we chose the wrong container type and fail the match as a result, that's too bad. (The desktop CLR has the // same issue.) // LowLevelDictionary<string, QHandle> dict = new LowLevelDictionary<string, QHandle>(); foreach (QScopeDefinition scope in AllScopes) { MetadataReader reader = scope.Reader; ScopeDefinition scopeDefinition = scope.ScopeDefinition; IEnumerable<NamespaceDefinitionHandle> topLevelNamespaceHandles = new NamespaceDefinitionHandle[] { scopeDefinition.RootNamespaceDefinition }; IEnumerable<NamespaceDefinitionHandle> allNamespaceHandles = reader.GetTransitiveNamespaces(topLevelNamespaceHandles); foreach (NamespaceDefinitionHandle namespaceHandle in allNamespaceHandles) { string ns = namespaceHandle.ToNamespaceName(reader); if (ns.Length != 0) ns = ns + "."; ns = ns.ToLower(); NamespaceDefinition namespaceDefinition = namespaceHandle.GetNamespaceDefinition(reader); foreach (TypeDefinitionHandle typeDefinitionHandle in namespaceDefinition.TypeDefinitions) { string fullName = ns + typeDefinitionHandle.GetTypeDefinition(reader).Name.GetString(reader).ToLower(); QHandle existingValue; if (!dict.TryGetValue(fullName, out existingValue)) { dict.Add(fullName, new QHandle(reader, typeDefinitionHandle)); } } foreach (TypeForwarderHandle typeForwarderHandle in namespaceDefinition.TypeForwarders) { string fullName = ns + typeForwarderHandle.GetTypeForwarder(reader).Name.GetString(reader).ToLower(); QHandle existingValue; if (!dict.TryGetValue(fullName, out existingValue)) { dict.Add(fullName, new QHandle(reader, typeForwarderHandle)); } } } } return dict; }
// // Returns the native layout info reader // internal static unsafe NativeReader GetNativeLayoutInfoReader(TypeManagerHandle moduleHandle) { Debug.Assert(!moduleHandle.IsNull); t_moduleNativeReaders ??= new LowLevelDictionary <TypeManagerHandle, NativeReader>(); NativeReader result; if (t_moduleNativeReaders.TryGetValue(moduleHandle, out result)) { return(result); } byte *pBlob; uint cbBlob; if (RuntimeAugments.FindBlob(moduleHandle, (int)ReflectionMapBlob.NativeLayoutInfo, new IntPtr(&pBlob), new IntPtr(&cbBlob))) { result = new NativeReader(pBlob, cbBlob); } t_moduleNativeReaders.Add(moduleHandle, result); return(result); }
private static IDictionary GetEnvironmentVariablesCore(EnvironmentVariableTarget target) { if (target == EnvironmentVariableTarget.Process) { return(GetEnvironmentVariablesCore()); } else { RegistryKey baseKey; string keyName; if (target == EnvironmentVariableTarget.Machine) { baseKey = Registry.LocalMachine; keyName = @"System\CurrentControlSet\Control\Session Manager\Environment"; } else { Debug.Assert(target == EnvironmentVariableTarget.User); baseKey = Registry.CurrentUser; keyName = @"Environment"; } using (RegistryKey environmentKey = baseKey.OpenSubKey(keyName, writable: false)) { var table = new LowLevelDictionary <string, string>(); if (environmentKey != null) { foreach (string name in environmentKey.GetValueNames()) { table.Add(name, environmentKey.GetValue(name, "").ToString()); } } return(table); } } }
private static IDictionary GetEnvironmentVariablesCore(EnvironmentVariableTarget target) { if (target == EnvironmentVariableTarget.Process) { return GetEnvironmentVariablesCore(); } else { RegistryKey baseKey; string keyName; if (target == EnvironmentVariableTarget.Machine) { baseKey = Registry.LocalMachine; keyName = @"System\CurrentControlSet\Control\Session Manager\Environment"; } else { Debug.Assert(target == EnvironmentVariableTarget.User); baseKey = Registry.CurrentUser; keyName = @"Environment"; } using (RegistryKey environmentKey = baseKey.OpenSubKey(keyName, writable: false)) { var table = new LowLevelDictionary<string, string>(); if (environmentKey != null) { foreach (string name in environmentKey.GetValueNames()) { table.Add(name, environmentKey.GetValue(name, "").ToString()); } } return table; } } }
private static LowLevelDictionary <string, TypeFlags> InitPrimitiveTypesDictionary() { LowLevelDictionary <string, TypeFlags> result = new LowLevelDictionary <string, TypeFlags>(); result.Add("Void", TypeFlags.Void); result.Add("Boolean", TypeFlags.Boolean); result.Add("Char", TypeFlags.Char); result.Add("SByte", TypeFlags.SByte); result.Add("Byte", TypeFlags.Byte); result.Add("Int16", TypeFlags.Int16); result.Add("UInt16", TypeFlags.UInt16); result.Add("Int32", TypeFlags.Int32); result.Add("UInt32", TypeFlags.UInt32); result.Add("Int64", TypeFlags.Int64); result.Add("UInt64", TypeFlags.UInt64); result.Add("IntPtr", TypeFlags.IntPtr); result.Add("UIntPtr", TypeFlags.UIntPtr); result.Add("Single", TypeFlags.Single); result.Add("Double", TypeFlags.Double); return(result); }
internal ModuleMap(ModuleInfo[] modules) { Modules = modules; HandleToModuleIndex = new LowLevelDictionary<IntPtr, int>(); for (int moduleIndex = 0; moduleIndex < Modules.Length; moduleIndex++) { HandleToModuleIndex.Add(Modules[moduleIndex].Handle, moduleIndex); } }
public static unsafe IntPtr Get(RuntimeTypeHandle constraintType, RuntimeTypeHandle constrainedMethodType, int constrainedMethodSlot, bool directConstrainedCall = false) { lock (s_nonGenericConstrainedCallDescs) { // Get list of constrained call descs associated with a given type LowLevelList <IntPtr> associatedCallDescs; if (!s_nonGenericConstrainedCallDescs.TryGetValue(constraintType, out associatedCallDescs)) { associatedCallDescs = new LowLevelList <IntPtr>(); s_nonGenericConstrainedCallDescs.Add(constraintType, associatedCallDescs); } // Perform linear scan of associated call descs to see if one matches for (int i = 0; i < associatedCallDescs.Count; i++) { NonGenericConstrainedCallDesc *callDesc = (NonGenericConstrainedCallDesc *)associatedCallDescs[i]; Debug.Assert(constraintType.Equals(callDesc->_constraintType)); if (callDesc->_constrainedMethodSlot != constrainedMethodSlot) { continue; } if (!callDesc->_constrainedMethodType.Equals(constrainedMethodType)) { continue; } // Found matching entry. return(associatedCallDescs[i]); } // Did not find match, allocate a new one and add it to the lookup list IntPtr newCallDescPtr = MemoryHelpers.AllocateMemory(sizeof(NonGenericConstrainedCallDesc)); NonGenericConstrainedCallDesc *newCallDesc = (NonGenericConstrainedCallDesc *)newCallDescPtr; newCallDesc->_exactTarget = IntPtr.Zero; if (directConstrainedCall) { newCallDesc->_lookupFunc = RuntimeAugments.GetUniversalTransitionThunk(); } else { if (RuntimeAugments.IsValueType(constraintType)) { newCallDesc->_lookupFunc = s_resolveCallOnValueTypeFuncPtr; } else { newCallDesc->_lookupFunc = s_resolveCallOnReferenceTypeFuncPtr; } } newCallDesc->_constraintType = constraintType; newCallDesc->_constrainedMethodSlot = constrainedMethodSlot; newCallDesc->_constrainedMethodType = constrainedMethodType; associatedCallDescs.Add(newCallDescPtr); return(newCallDescPtr); } }
// // Main iterator. // private IEnumerable <CustomAttributeData> GetMatchingCustomAttributesIterator(E element, Func <Type, bool> rawPassesFilter, bool inherit) { Func <Type, bool> passesFilter = delegate(Type attributeType) { // Windows prohibits instantiating WinRT custom attributes. Filter them from the search as the desktop CLR does. TypeAttributes typeAttributes = attributeType.Attributes; if (0 != (typeAttributes & TypeAttributes.WindowsRuntime)) { return(false); } return(rawPassesFilter(attributeType)); }; LowLevelList <CustomAttributeData> immediateResults = new LowLevelList <CustomAttributeData>(); foreach (CustomAttributeData cad in GetDeclaredCustomAttributes(element)) { if (passesFilter(cad.AttributeType)) { yield return(cad); immediateResults.Add(cad); } } if (inherit) { // Because the "inherit" parameter defaults to "true", we probably get here for a lot of elements that // don't actually have any inheritance chains. Try to avoid doing any unnecessary setup for the inheritance walk // unless we have to. element = GetParent(element); if (element != null) { // This dictionary serves two purposes: // - Let us know which attribute types we've encountered at lower levels so we can block them from appearing twice in the results // if appropriate. // // - Cache the results of retrieving the usage attribute. // LowLevelDictionary <TypeUnificationKey, AttributeUsageAttribute> encounteredTypes = new LowLevelDictionary <TypeUnificationKey, AttributeUsageAttribute>(11); for (int i = 0; i < immediateResults.Count; i++) { Type attributeType = immediateResults[i].AttributeType; AttributeUsageAttribute usage; TypeUnificationKey attributeTypeKey = new TypeUnificationKey(attributeType); if (!encounteredTypes.TryGetValue(attributeTypeKey, out usage)) { encounteredTypes.Add(attributeTypeKey, null); } } do { foreach (CustomAttributeData cad in GetDeclaredCustomAttributes(element)) { Type attributeType = cad.AttributeType; if (!passesFilter(attributeType)) { continue; } AttributeUsageAttribute usage; TypeUnificationKey attributeTypeKey = new TypeUnificationKey(attributeType); if (!encounteredTypes.TryGetValue(attributeTypeKey, out usage)) { // Type was not encountered before. Only include it if it is inheritable. usage = GetAttributeUsage(attributeType); encounteredTypes.Add(attributeTypeKey, usage); if (usage.Inherited) { yield return(cad); } } else { if (usage == null) { usage = GetAttributeUsage(attributeType); } encounteredTypes[attributeTypeKey] = usage; // Type was encountered at a lower level. Only include it if its inheritable AND allowMultiple. if (usage.Inherited && usage.AllowMultiple) { yield return(cad); } } } }while ((element = GetParent(element)) != null); } } }
private static LowLevelDictionary<string, char> GenerateLookupTable() { // e[0] is unicode char, e[1] is '-', e[2+] is entity string LowLevelDictionary<string, char> lookupTable = new LowLevelDictionary<string, char>(StringComparer.Ordinal); foreach (string e in s_entitiesList) { lookupTable.Add(e.Substring(2), e[0]); } return lookupTable; }
public TypeDesc ResolveRuntimeTypeHandle(RuntimeTypeHandle rtth) { TypeDesc returnedType; if (_runtimeTypeHandleResolutionCache.TryGetValue(rtth, out returnedType)) { return(returnedType); } if (rtth.Equals(CanonType.RuntimeTypeHandle)) { returnedType = CanonType; } else if (rtth.Equals(UniversalCanonType.RuntimeTypeHandle)) { returnedType = UniversalCanonType; } else if (RuntimeAugments.IsGenericTypeDefinition(rtth)) { returnedType = TryGetMetadataBasedTypeFromRuntimeTypeHandle_Uncached(rtth); if (returnedType == null) { unsafe { TypeDesc[] genericParameters = new TypeDesc[rtth.ToEETypePtr()->GenericArgumentCount]; for (int i = 0; i < genericParameters.Length; i++) { genericParameters[i] = GetSignatureVariable(i, false); } returnedType = new NoMetadataType(this, rtth, null, new Instantiation(genericParameters), rtth.GetHashCode()); } } } else if (RuntimeAugments.IsGenericType(rtth)) { RuntimeTypeHandle typeDefRuntimeTypeHandle; RuntimeTypeHandle[] genericArgRuntimeTypeHandles; typeDefRuntimeTypeHandle = RuntimeAugments.GetGenericInstantiation(rtth, out genericArgRuntimeTypeHandles); DefType typeDef = (DefType)ResolveRuntimeTypeHandle(typeDefRuntimeTypeHandle); Instantiation genericArgs = ResolveRuntimeTypeHandles(genericArgRuntimeTypeHandles); returnedType = ResolveGenericInstantiation(typeDef, genericArgs); } else if (RuntimeAugments.IsArrayType(rtth)) { RuntimeTypeHandle elementTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(rtth); TypeDesc elementType = ResolveRuntimeTypeHandle(elementTypeHandle); unsafe { if (rtth.ToEETypePtr()->IsSzArray) { returnedType = GetArrayType(elementType); } else { returnedType = GetArrayType(elementType, rtth.ToEETypePtr()->ArrayRank); } } } else if (RuntimeAugments.IsUnmanagedPointerType(rtth)) { RuntimeTypeHandle targetTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(rtth); TypeDesc targetType = ResolveRuntimeTypeHandle(targetTypeHandle); returnedType = GetPointerType(targetType); } else if (RuntimeAugments.IsByRefType(rtth)) { RuntimeTypeHandle targetTypeHandle = RuntimeAugments.GetRelatedParameterTypeHandle(rtth); TypeDesc targetType = ResolveRuntimeTypeHandle(targetTypeHandle); returnedType = GetByRefType(targetType); } else { returnedType = TryGetMetadataBasedTypeFromRuntimeTypeHandle_Uncached(rtth); if (returnedType == null) { returnedType = new NoMetadataType(this, rtth, null, Instantiation.Empty, rtth.GetHashCode()); } } // We either retrieved an existing DefType that is already registered with the runtime // or one that is not associated with an MethodTable yet. If it's not associated, associate it. if (returnedType.RuntimeTypeHandle.IsNull()) { TypeBuilderState state = returnedType.GetTypeBuilderStateIfExist(); bool skipStoringRuntimeTypeHandle = false; // If we've already attempted to lookup and failed to retrieve this type handle, we // may have already decided to create a new one. In that case, do not attempt to abort // that creation process as it may have already begun the process of type creation if (state != null && state.AttemptedAndFailedToRetrieveTypeHandle) { skipStoringRuntimeTypeHandle = true; } if (!skipStoringRuntimeTypeHandle) { returnedType.SetRuntimeTypeHandleUnsafe(rtth); } } _runtimeTypeHandleResolutionCache.Add(rtth, returnedType); return(returnedType.WithDebugName()); }
private static LowLevelDictionary<string, TypeFlags> InitPrimitiveTypesDictionary() { LowLevelDictionary<string, TypeFlags> result = new LowLevelDictionary<string, TypeFlags>(); result.Add("Void", TypeFlags.Void); result.Add("Boolean", TypeFlags.Boolean); result.Add("Char", TypeFlags.Char); result.Add("SByte", TypeFlags.SByte); result.Add("Byte", TypeFlags.Byte); result.Add("Int16", TypeFlags.Int16); result.Add("UInt16", TypeFlags.UInt16); result.Add("Int32", TypeFlags.Int32); result.Add("UInt32", TypeFlags.UInt32); result.Add("Int64", TypeFlags.Int64); result.Add("UInt64", TypeFlags.UInt64); result.Add("IntPtr", TypeFlags.IntPtr); result.Add("UIntPtr", TypeFlags.UIntPtr); result.Add("Single", TypeFlags.Single); result.Add("Double", TypeFlags.Double); return result; }