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