private RuntimeFatMethodParameterInfo(MethodBase member, MethodHandle methodHandle, int position, ParameterHandle parameterHandle, MetadataReader reader, Handle typeHandle, TypeContext typeContext) : base(member, position, reader, typeHandle, typeContext) { _methodHandle = methodHandle; _parameterHandle = parameterHandle; _parameter = parameterHandle.GetParameter(reader); }
protected RuntimeMethodParameterInfo(MethodBase member, int position, MetadataReader reader, Handle typeHandle, TypeContext typeContext) : base(member, position) { Reader = reader; _typeHandle = typeHandle; _typeContext = typeContext; }
// TODO // bool _hasModifiers; public NativeFormatSignatureParser(NativeFormatMetadataUnit metadataUnit, Handle signatureHandle, MetadataReader metadataReader) { _metadataUnit = metadataUnit; _signatureHandle = signatureHandle; _metadataReader = metadataReader; // _hasModifiers = false; }
public static uint Read(this NativeReader reader, uint offset, out Handle handle) { uint rawValue; offset = reader.DecodeUnsigned(offset, out rawValue); handle = new Handle((HandleType)(byte)rawValue, (int)(rawValue >> 8)); return offset; }
public static bool GetAttributeTypeAndConstructor(this MetadataReader metadataReader, CustomAttributeHandle attributeHandle, out Handle attributeType, out Handle attributeCtor) { CustomAttribute attribute = metadataReader.GetCustomAttribute(attributeHandle); attributeCtor = attribute.Constructor; attributeType = attribute.GetAttributeTypeHandle(metadataReader); return true; }
public static bool GetAttributeTypeNamespaceAndName(this MetadataReader metadataReader, Handle attributeType, out string namespaceString, out ConstantStringValueHandle nameHandle) { namespaceString = null; nameHandle = default(ConstantStringValueHandle); if (attributeType.HandleType == HandleType.TypeReference) { TypeReference typeRefRow = metadataReader.GetTypeReference(attributeType.ToTypeReferenceHandle(metadataReader)); HandleType handleType = typeRefRow.ParentNamespaceOrType.HandleType; // Nested type? if (handleType == HandleType.TypeReference || handleType == HandleType.TypeDefinition) return false; nameHandle = typeRefRow.TypeName; namespaceString = metadataReader.GetNamespaceName(typeRefRow.ParentNamespaceOrType.ToNamespaceReferenceHandle(metadataReader)); return true; } else if (attributeType.HandleType == HandleType.TypeDefinition) { var def = metadataReader.GetTypeDefinition(attributeType.ToTypeDefinitionHandle(metadataReader)); // Nested type? if (IsNested(def.Flags)) return false; nameHandle = def.Name; namespaceString = metadataReader.GetNamespaceName(def.NamespaceDefinition); return true; } else { // unsupported metadata return false; } }
} // ToTypeForwarderHandle internal TypeInstantiationSignatureHandle ToTypeInstantiationSignatureHandle(Handle handle) { return new TypeInstantiationSignatureHandle(handle._value); } // ToTypeInstantiationSignatureHandle
} // ToTypeDefinitionHandle internal TypeForwarderHandle ToTypeForwarderHandle(Handle handle) { return new TypeForwarderHandle(handle._value); } // ToTypeForwarderHandle
} // ToScopeReferenceHandle internal TypeDefinitionHandle ToTypeDefinitionHandle(Handle handle) { return new TypeDefinitionHandle(handle._value); } // ToTypeDefinitionHandle
} // ToScopeDefinitionHandle internal ScopeReferenceHandle ToScopeReferenceHandle(Handle handle) { return new ScopeReferenceHandle(handle._value); } // ToScopeReferenceHandle
} // ToMethodTypeVariableSignatureHandle internal NamedArgumentHandle ToNamedArgumentHandle(Handle handle) { return new NamedArgumentHandle(handle._value); } // ToNamedArgumentHandle
public bool Equals(Handle handle) { return(_value == handle._value); }
} // ToTypeSpecificationHandle internal TypeVariableSignatureHandle ToTypeVariableSignatureHandle(Handle handle) { return new TypeVariableSignatureHandle(handle._value); } // ToTypeVariableSignatureHandle
} // ToPropertyHandle internal PropertySignatureHandle ToPropertySignatureHandle(Handle handle) { return new PropertySignatureHandle(handle._value); } // ToPropertySignatureHandle
} // ToParameterHandle internal ParameterTypeSignatureHandle ToParameterTypeSignatureHandle(Handle handle) { return new ParameterTypeSignatureHandle(handle._value); } // ToParameterTypeSignatureHandle
} // ToParameterTypeSignatureHandle internal PointerSignatureHandle ToPointerSignatureHandle(Handle handle) { return new PointerSignatureHandle(handle._value); } // ToPointerSignatureHandle
} // ToNamespaceReferenceHandle internal ParameterHandle ToParameterHandle(Handle handle) { return new ParameterHandle(handle._value); } // ToParameterHandle
} // ToNamespaceDefinitionHandle internal NamespaceReferenceHandle ToNamespaceReferenceHandle(Handle handle) { return new NamespaceReferenceHandle(handle._value); } // ToNamespaceReferenceHandle
} // ToNamedArgumentHandle internal NamespaceDefinitionHandle ToNamespaceDefinitionHandle(Handle handle) { return new NamespaceDefinitionHandle(handle._value); } // ToNamespaceDefinitionHandle
} // ToTypeInstantiationSignatureHandle internal TypeReferenceHandle ToTypeReferenceHandle(Handle handle) { return new TypeReferenceHandle(handle._value); } // ToTypeReferenceHandle
/// <summary> /// Idempotent - simply returns the provided handle value. Exists for /// consistency so that generated code does not need to handle this /// as a special case. /// </summary> public Handle ToHandle(Handle handle) { return handle; }
} // ToTypeReferenceHandle internal TypeSpecificationHandle ToTypeSpecificationHandle(Handle handle) { return new TypeSpecificationHandle(handle._value); } // ToTypeSpecificationHandle
} // Read public static uint Read(this NativeReader reader, uint offset, out Handle[] values) { uint count; offset = reader.DecodeUnsigned(offset, out count); if (count == 0) { values = s_emptyHandleArray; } else { values = new Handle[count]; for (uint i = 0; i < count; ++i) { Handle tmp; offset = reader.Read(offset, out tmp); values[i] = tmp; } } return offset; } // Read
internal ConstantCharValueHandle(Handle handle) : this(handle._value) { }
/// <summary> /// Idempotent - simply returns the provided handle value. Exists for /// consistency so that generated code does not need to handle this /// as a special case. /// </summary> public Handle ToHandle(Handle handle) { return(handle); }
} // ToQualifiedFieldHandle internal QualifiedMethodHandle ToQualifiedMethodHandle(Handle handle) { return new QualifiedMethodHandle(handle._value); } // ToQualifiedMethodHandle
} // ToMethodSignatureHandle internal MethodTypeVariableSignatureHandle ToMethodTypeVariableSignatureHandle(Handle handle) { return new MethodTypeVariableSignatureHandle(handle._value); } // ToMethodTypeVariableSignatureHandle
/// <summary> /// Returns true if handle is null. /// </summary> public bool IsNull(Handle handle) { return handle._value == NullHandle._value; }
} // ToQualifiedMethodHandle internal ReturnTypeSignatureHandle ToReturnTypeSignatureHandle(Handle handle) { return new ReturnTypeSignatureHandle(handle._value); } // ToReturnTypeSignatureHandle
public bool Equals(Handle handle) { return _value == handle._value; }
} // ToReturnTypeSignatureHandle internal SZArraySignatureHandle ToSZArraySignatureHandle(Handle handle) { return new SZArraySignatureHandle(handle._value); } // ToSZArraySignatureHandle
} // ToSZArraySignatureHandle internal ScopeDefinitionHandle ToScopeDefinitionHandle(Handle handle) { return new ScopeDefinitionHandle(handle._value); } // ToScopeDefinitionHandle
/// <summary> /// Returns true if handle is null. /// </summary> public bool IsNull(Handle handle) { return(handle._value == NullHandle._value); }