void PatchResources()
{
ManifestResourceTable resourceTable = (ManifestResourceTable)stripped_tables [ManifestResourceTable.RId];
if (resourceTable == null)
{
return;
}
for (int i = 0; i < resourceTable.Rows.Count; i++)
{
ManifestResourceRow resourceRow = resourceTable [i];
if (resourceRow.Implementation.RID != 0)
{
continue;
}
foreach (Resource resource in assembly.MainModule.Resources)
{
EmbeddedResource er = resource as EmbeddedResource;
if (er == null)
{
continue;
}
if (resource.Name != original.MetadataRoot.Streams.StringsHeap [resourceRow.Name])
{
continue;
}
resourceRow.Offset = metadata_writer.AddResource(er.Data);
}
}
}
/// <summary>
/// Creates a manifest resource from a manifest resource metadata row.
/// </summary>
/// <param name="parentModule">The module that contains the resource.</param>
/// <param name="token">The token to initialize the resource for.</param>
/// <param name="row">The metadata table row to base the resource \on.</param>
public SerializedManifestResource(SerializedModuleDefinition parentModule, MetadataToken token, ManifestResourceRow row)
: base(token)
{
_parentModule = parentModule ?? throw new ArgumentNullException(nameof(parentModule));
_row = row;
Attributes = row.Attributes;
((IOwnedCollectionElement <ModuleDefinition>) this).Owner = parentModule;
}
public override void FromRawData(byte [] buff, int offs, int numRows)
{
for (int i = numRows; --i >= 0;)
{
Row row = new ManifestResourceRow(this);
row.FromRawData(buff, offs);
Add(row);
offs += ManifestResourceRow.LogicalSize;
}
}
void AddManifestResource(uint offset, string name, ManifestResourceAttributes flags, MetadataToken impl)
{
ManifestResourceTable mrTable = m_tableWriter.GetManifestResourceTable();
ManifestResourceRow mrRow = m_rowWriter.CreateManifestResourceRow(
offset,
flags,
m_mdWriter.AddString(name),
impl);
mrTable.Rows.Add(mrRow);
}
/// <summary>
/// Reads the specified token.
/// </summary>
/// <param name="token">The token.</param>
/// <param name="result">The result.</param>
public void Read(TokenTypes token, out ManifestResourceRow result)
{
if ((token & TokenTypes.TableMask) != TokenTypes.ManifestResource)
{
throw new ArgumentException("Invalid token type for ManifestResourceRow.", "token");
}
using (BinaryReader reader = CreateReaderForToken(token))
{
result = new ManifestResourceRow(reader.ReadUInt32(), (ManifestResourceAttributes)reader.ReadUInt32(), ReadIndexValue(reader, IndexType.StringHeap), ReadIndexValue(reader, IndexType.Implementation));
}
}
public override void VisitResourceCollection(ResourceCollection resources)
{
if (!m_tHeap.HasTable(ManifestResourceTable.RId))
{
return;
}
ManifestResourceTable mrTable = m_tableReader.GetManifestResourceTable();
FileTable fTable = m_tableReader.GetFileTable();
BinaryReader br;
for (int i = 0; i < mrTable.Rows.Count; i++)
{
ManifestResourceRow mrRow = mrTable [i];
if (mrRow.Implementation.RID == 0)
{
EmbeddedResource eres = new EmbeddedResource(
ReadString(mrRow.Name), mrRow.Flags);
br = m_ir.MetadataReader.GetDataReader(
m_img.CLIHeader.Resources.VirtualAddress);
br.BaseStream.Position += mrRow.Offset;
eres.Data = br.ReadBytes(br.ReadInt32());
resources.Add(eres);
continue;
}
switch (mrRow.Implementation.TokenType)
{
case TokenType.File:
FileRow fRow = fTable [(int)mrRow.Implementation.RID - 1];
LinkedResource lres = new LinkedResource(
ReadString(mrRow.Name), mrRow.Flags,
ReadString(fRow.Name));
lres.Hash = ReadBlob(fRow.HashValue);
resources.Add(lres);
break;
case TokenType.AssemblyRef:
AssemblyNameReference asm =
m_module.AssemblyReferences [(int)mrRow.Implementation.RID - 1];
AssemblyLinkedResource alr = new AssemblyLinkedResource(
ReadString(mrRow.Name),
mrRow.Flags, asm);
resources.Add(alr);
break;
}
}
}
/// <summary>
/// Adds a single manifest resource to the buffer.
/// </summary>
/// <param name="resource">The resource to add.</param>
/// <returns>The new metadata token of the resource.</returns>
public MetadataToken AddManifestResource(ManifestResource resource)
{
uint offset = resource.Offset;
if (resource.IsEmbedded)
{
using var stream = new MemoryStream();
resource.EmbeddedDataSegment.Write(new BinaryStreamWriter(stream));
offset = Resources.GetResourceDataOffset(stream.ToArray());
}
var table = Metadata.TablesStream.GetTable <ManifestResourceRow>(TableIndex.ManifestResource);
var row = new ManifestResourceRow(
offset,
resource.Attributes,
Metadata.StringsStream.GetStringIndex(resource.Name),
AddImplementation(resource.Implementation));
var token = table.Add(row);
AddCustomAttributes(token, resource);
return(token);
}
public virtual void VisitManifestResourceRow(ManifestResourceRow row)
{
}
void IMetadataProvider.Read(TokenTypes token, out ManifestResourceRow result)
{
TableHeap theap = (TableHeap)_streams[(int)HeapType.Tables];
theap.Read(token, out result);
}
public virtual void VisitManifestResourceRow(ManifestResourceRow row)
{
}
