|
public static FromReader ( MetadataHeader header, IBinaryStreamReader reader ) : |
||
| header | MetadataHeader | |
| reader | IBinaryStreamReader | |
| return | ||
/// <summary>
/// Reads a single pinned type signature at the current position of the provided stream reader.
/// </summary>
/// <param name="image">The image the signature resides in.</param>
/// <param name="reader">The reader to use.</param>
/// <param name="protection">The recursion protection that is used to detect malicious loops in the metadata.</param>
/// <returns>The read signature.</returns>
public static PinnedTypeSignature FromReader(
MetadataImage image,
IBinaryStreamReader reader,
RecursionProtection protection)
{
return(new PinnedTypeSignature(TypeSignature.FromReader(image, reader, false, protection)));
}
public new static GenericInstanceTypeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
if (!reader.CanRead(sizeof(byte)))
{
return(null);
}
var elementType = (ElementType)reader.ReadByte();
var type = ReadTypeDefOrRef(header, reader);
var signature = new GenericInstanceTypeSignature(type)
{
IsValueType = elementType == ElementType.ValueType
};
uint count;
if (!reader.TryReadCompressedUInt32(out count))
{
return(signature);
}
for (int i = 0; i < count; i++)
{
signature.GenericArguments.Add(TypeSignature.FromReader(header, reader));
}
return(signature);
}
public new static OptionalModifierSignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
long position = reader.Position;
return(new OptionalModifierSignature(ReadTypeDefOrRef(image, reader),
TypeSignature.FromReader(image, reader)));
}
/// <summary>
/// Reads a single property signature at the current position of the provided stream reader.
/// </summary>
/// <param name="image">The image the signature resides in.</param>
/// <param name="reader">The reader to use.</param>
/// <param name="readToEnd">Determines whether any extra data after the signature should be read and
/// put into the <see cref="ExtendableBlobSignature.ExtraData"/> property.</param>
/// <param name="protection">The recursion protection that is used to detect malicious loops in the metadata.</param>
/// <returns>The read signature.</returns>
public new static PropertySignature FromReader(
MetadataImage image,
IBinaryStreamReader reader,
bool readToEnd,
RecursionProtection protection)
{
var signature = new PropertySignature
{
Attributes = (CallingConventionAttributes)reader.ReadByte(),
};
if (!reader.TryReadCompressedUInt32(out uint paramCount))
{
return(null);
}
signature.PropertyType = TypeSignature.FromReader(image, reader, false, protection);
for (int i = 0; i < paramCount; i++)
{
signature.Parameters.Add(ParameterSignature.FromReader(image, reader, protection));
}
if (readToEnd)
{
signature.ExtraData = reader.ReadToEnd();
}
return(signature);
}
public static ParameterSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
return(new ParameterSignature
{
ParameterType = TypeSignature.FromReader(header, reader),
});
}
/// <summary>
/// Reads a single generic instance type signature at the current position of the provided stream reader.
/// </summary>
/// <param name="image">The image the signature was defined in.</param>
/// <param name="reader">The reader to use.</param>
/// <param name="protection">The recursion protection that is used to detect malicious loops in the metadata.</param>
/// <returns>The read signature.</returns>
public static GenericInstanceTypeSignature FromReader(
MetadataImage image,
IBinaryStreamReader reader,
RecursionProtection protection)
{
if (!reader.CanRead(sizeof(byte)))
{
return(null);
}
var elementType = (ElementType)reader.ReadByte();
var type = ReadTypeDefOrRef(image, reader, protection);
var signature = new GenericInstanceTypeSignature(type)
{
IsValueType = elementType == ElementType.ValueType
};
if (!reader.TryReadCompressedUInt32(out uint count))
{
return(signature);
}
for (int i = 0; i < count; i++)
{
signature.GenericArguments.Add(TypeSignature.FromReader(image, reader, false, protection));
}
return(signature);
}
/// <summary>
/// Reads a single annotated type signature at the current position of the provided stream reader.
/// </summary>
/// <param name="image">The image the signature resides in.</param>
/// <param name="reader">The reader to use.</param>
/// <param name="protection">The recursion protection that is used to detect malicious loops in the metadata.</param>
/// <returns>The read signature.</returns>
public static RequiredModifierSignature FromReader(
MetadataImage image,
IBinaryStreamReader reader,
RecursionProtection protection)
{
return(new RequiredModifierSignature(ReadTypeDefOrRef(image, reader, protection),
TypeSignature.FromReader(image, reader, false, protection)));
}
public new static FieldSignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
return(new FieldSignature
{
Attributes = (CallingConventionAttributes)reader.ReadByte(),
FieldType = TypeSignature.FromReader(image, reader),
});
}
public static ParameterSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
return(new ParameterSignature
{
StartOffset = reader.Position,
ParameterType = TypeSignature.FromReader(header, reader),
});
}
public new static PinnedTypeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
long position = reader.StartPosition;
return(new PinnedTypeSignature(TypeSignature.FromReader(header, reader))
{
StartOffset = reader.Position,
});
}
public static VariableSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
long position = reader.Position;
return(new VariableSignature(TypeSignature.FromReader(header, reader))
{
StartOffset = position
});
}
public new static ByReferenceTypeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
long position = reader.Position;
return(new ByReferenceTypeSignature(TypeSignature.FromReader(header, reader))
{
StartOffset = position
});
}
public new static FieldSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
return(new FieldSignature
{
StartOffset = reader.Position,
Attributes = (CallingConventionAttributes)reader.ReadByte(),
FieldType = TypeSignature.FromReader(header, reader),
});
}
public new static RequiredModifierSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
long position = reader.Position;
return(new RequiredModifierSignature(ReadTypeDefOrRef(header, reader),
TypeSignature.FromReader(header, reader))
{
StartOffset = position
});
}
/// <summary>
/// Reads a single field signature at the current position of the provided stream reader.
/// </summary>
/// <param name="image">The image the field is defined in.</param>
/// <param name="reader">The reader to use.</param>
/// <param name="readToEnd">Determines whether any extra data after the signature should be read and
/// put into the <see cref="ExtendableBlobSignature.ExtraData"/> property.</param>
/// <param name="protection">The recursion protection that is used to detect malicious loops in the metadata.</param>
/// <returns>The read signature.</returns>
public new static FieldSignature FromReader(
MetadataImage image,
IBinaryStreamReader reader,
bool readToEnd,
RecursionProtection protection)
{
return(new FieldSignature
{
Attributes = (CallingConventionAttributes)reader.ReadByte(),
FieldType = TypeSignature.FromReader(image, reader, false, protection),
ExtraData = readToEnd ? reader.ReadToEnd() : null
});
}
/// <summary>
/// Reads a single method signature at the current position of the provided stream reader.
/// </summary>
/// <param name="image">The image the field is defined in.</param>
/// <param name="reader">The reader to use.</param>
/// <param name="readToEnd">Determines whether any extra data after the signature should be read and
/// put into the <see cref="ExtendableBlobSignature.ExtraData"/> property.</param>
/// <param name="protection">The recursion protection that is used to detect malicious loops in the metadata.</param>
/// <returns>The read signature.</returns>
public new static MethodSignature FromReader(
MetadataImage image,
IBinaryStreamReader reader,
bool readToEnd,
RecursionProtection protection)
{
if (!reader.CanRead(sizeof(byte)))
{
return(null);
}
var signature = new MethodSignature
{
Attributes = (CallingConventionAttributes)reader.ReadByte()
};
if (signature.IsGeneric)
{
if (!reader.TryReadCompressedUInt32(out uint genericParameterCount))
{
return(signature);
}
signature.GenericParameterCount = (int)genericParameterCount;
}
if (!reader.TryReadCompressedUInt32(out uint parameterCount))
{
return(signature);
}
signature.ReturnType = TypeSignature.FromReader(image, reader);
for (int i = 0; i < parameterCount; i++)
{
signature.Parameters.Add(ParameterSignature.FromReader(image, reader, protection));
}
if (readToEnd)
{
signature.ExtraData = reader.ReadToEnd();
}
return(signature);
}
public new static GenericInstanceMethodSignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
var signature = new GenericInstanceMethodSignature
{
Attributes = (CallingConventionAttributes)reader.ReadByte()
};
uint count;
if (!reader.TryReadCompressedUInt32(out count))
{
return(signature);
}
for (int i = 0; i < count; i++)
{
signature.GenericArguments.Add(TypeSignature.FromReader(image, reader));
}
return(signature);
}
public new static MethodSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
if (!reader.CanRead(sizeof(byte)))
{
return(null);
}
var signature = new MethodSignature
{
StartOffset = reader.Position,
Attributes = (CallingConventionAttributes)reader.ReadByte()
};
if (signature.IsGeneric)
{
uint genericParameterCount;
if (!reader.TryReadCompressedUInt32(out genericParameterCount))
{
return(signature);
}
signature.GenericParameterCount = (int)genericParameterCount;
}
uint parameterCount;
if (!reader.TryReadCompressedUInt32(out parameterCount))
{
return(signature);
}
signature.ReturnType = TypeSignature.FromReader(header, reader);
for (int i = 0; i < parameterCount; i++)
{
signature.Parameters.Add(ParameterSignature.FromReader(header, reader));
}
return(signature);
}
public new static PropertySignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
var signature = new PropertySignature
{
Attributes = (CallingConventionAttributes)reader.ReadByte(),
};
uint paramCount;
if (!reader.TryReadCompressedUInt32(out paramCount))
{
return(null);
}
signature.PropertyType = TypeSignature.FromReader(image, reader);
for (int i = 0; i < paramCount; i++)
{
signature.Parameters.Add(ParameterSignature.FromReader(image, reader));
}
return(signature);
}
public new static SzArrayTypeSignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
return(new SzArrayTypeSignature(TypeSignature.FromReader(image, reader)));
}
public new static PinnedTypeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
return(new PinnedTypeSignature(TypeSignature.FromReader(header, reader)));
}
public new static PointerTypeSignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
long position = reader.Position;
return(new PointerTypeSignature(TypeSignature.FromReader(image, reader)));
}
public static ParameterSignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
return(new ParameterSignature(TypeSignature.FromReader(image, reader)));
}
public static VariableSignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
return(new VariableSignature(TypeSignature.FromReader(image, reader)));
}
public new static ByReferenceTypeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
return(new ByReferenceTypeSignature(TypeSignature.FromReader(header, reader)));
}
/// <summary>
/// Reads a single array type signature at the current position of the provided stream reader.
/// </summary>
/// <param name="image">The image the array was defined in.</param>
/// <param name="reader">The reader to use.</param>
/// <param name="protection">The recursion protection that is used to detect malicious loops in the metadata.</param>
/// <returns>The read array.</returns>
public static ArrayTypeSignature FromReader(MetadataImage image, IBinaryStreamReader reader, RecursionProtection protection)
{
var signature = new ArrayTypeSignature(TypeSignature.FromReader(image, reader, false, protection));
// Rank
if (!reader.TryReadCompressedUInt32(out uint rank))
{
return(signature);
}
// Sizes.
if (!reader.TryReadCompressedUInt32(out uint numSizes))
{
return(signature);
}
var sizes = new List <uint>();
for (int i = 0; i < numSizes; i++)
{
if (!reader.TryReadCompressedUInt32(out uint size))
{
return(signature);
}
sizes.Add(size);
}
// Lower bounds.
if (!reader.TryReadCompressedUInt32(out uint numLoBounds))
{
return(signature);
}
var loBounds = new List <uint>();
for (int i = 0; i < numLoBounds; i++)
{
if (!reader.TryReadCompressedUInt32(out uint bound))
{
return(signature);
}
loBounds.Add(bound);
}
// Create dimensions.
for (int i = 0; i < rank; i++)
{
var dimension = new ArrayDimension();
if (i < numSizes)
{
dimension.Size = (int)sizes[i];
}
if (i < numLoBounds)
{
dimension.LowerBound = (int)loBounds[i];
}
signature.Dimensions.Add(dimension);
}
return(signature);
}
public new static ArrayTypeSignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
long position = reader.Position;
var signature = new ArrayTypeSignature(TypeSignature.FromReader(image, reader));
uint rank;
if (!reader.TryReadCompressedUInt32(out rank))
{
return(signature);
}
uint numSizes;
if (!reader.TryReadCompressedUInt32(out numSizes))
{
return(signature);
}
var sizes = new uint[numSizes];
for (int i = 0; i < numSizes; i++)
{
if (!reader.TryReadCompressedUInt32(out sizes[i]))
{
return(signature);
}
}
uint numLoBounds;
if (!reader.TryReadCompressedUInt32(out numLoBounds))
{
return(signature);
}
var loBounds = new uint[numLoBounds];
for (int i = 0; i < numLoBounds; i++)
{
if (!reader.TryReadCompressedUInt32(out loBounds[i]))
{
return(signature);
}
}
for (int i = 0; i < rank; i++)
{
var dimension = new ArrayDimension();
if (i < numSizes)
{
dimension.Size = (int)sizes[i];
}
if (i < numLoBounds)
{
dimension.LowerBound = (int)loBounds[i];
}
signature.Dimensions.Add(dimension);
}
return(signature);
}
public new static RequiredModifierSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
return(new RequiredModifierSignature(ReadTypeDefOrRef(header, reader),
TypeSignature.FromReader(header, reader)));
}
public static VariableSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
return(new VariableSignature(TypeSignature.FromReader(header, reader)));
}
public new static ByReferenceTypeSignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
return(new ByReferenceTypeSignature(TypeSignature.FromReader(image, reader)));
}