MDStream.cs :  » Aspect-Oriented-Frameworks » Runtime-Assembly-Instrumentation-Library » Mono » PEToolkit » Metadata » C# / CSharp Open Source

/*
 * Copyright (c) 2002 Sergey Chaban <serge@wildwestsoftware.com>
 */

using System;
using System.IO;
using System.Text;
using System.Collections;
using System.Runtime.InteropServices;

namespace Mono.PEToolkit.Metadata{

  /// <summary>
  /// Metadata stream.
  /// </summary>
  public class MDStream {

    /// <summary>
    /// MetaData stream header as described
    /// in ECMA CLI specs, Partition II Metadata, 23.1.2
    /// </summary>
    protected class Header {
      internal uint offs;
      internal uint size;
      internal string name;


      public void Read(BinaryReader reader, MDStream stream)
      {  
        offs = reader.ReadUInt32 ();
        size = reader.ReadUInt32 ();

        StringBuilder name_builder = new StringBuilder ();
        while (true) {
          sbyte c = reader.ReadSByte();
          if (c == 0) 
            break;
          name_builder.Append ((char) c);
        }

        name = name_builder.ToString ();
        if (name.Length == 0)
          throw new BadImageException("Invalid stream name.");

        // Round up to dword boundary.
        long pos = reader.BaseStream.Position;
        if (stream != null) 
          pos -= stream.Root.filePos;
        pos += 3;
        pos &= ~3;
        if (stream != null) 
          pos += stream.Root.filePos;
        
        // Advance file pointer.
        reader.BaseStream.Position = pos;
      }
      
      public void Write (BinaryWriter writer, MDStream stream)
      {
        writer.Write (offs);
        writer.Write (size);

        for (int i=0; i<name.Length; i++)
          writer.Write ((sbyte)name[i]);
        writer.Write ((sbyte) '\0');  
      
        // Round up to dword boundary.
        long pos = writer.BaseStream.Position;
        if (stream != null) 
          pos -= stream.Root.filePos;
        pos += 3;
        pos &= ~3;
        if (stream != null) 
          pos += stream.Root.filePos;

        // Advance file pointer.
        writer.BaseStream.Position = pos;
      }

    } // header



    private MetaDataRoot root;
    private MDHeap heap;
    private Header hdr;
    private byte [] data;


    public MDStream(MetaDataRoot root)
    {
      this.root = root;
      hdr = new Header();
      data = null;
      heap = null;
    }


    public uint Offset {
      get {
        return hdr.offs;
      }
      set {
        hdr.offs = value;
      }
    }

    public uint Size {
      get {
        return hdr.size;
      }
      set {
        hdr.size = value;
      }
    }

    /// <summary>
    /// Name of the stream.
    /// </summary>
    /// <remarks>
    /// Stored on-disk as a null-terminated ASCII string,
    /// rounded up to 4-byte boundary.
    /// </remarks>
    public string Name {
      get {
        return hdr.name;
      }
      set {
        hdr.name = value;
      }
    }

    public byte [] RawData {
      get {
        return data;
      }
    }

    public MetaDataRoot Root {
      get {
        return root;
      }
    }

    public MDHeap Heap {
      get {
        lock (this) {
          if (heap == null) InitHeap();
          return heap;
        }
      }
    }


    /// <summary>
    /// Reads stream header and body from supplied BinaryReader.
    /// </summary>
    /// <remarks>
    /// Reader must be positioned at the first byte of metadata stream.
    /// </remarks>
    /// <param name="reader"></param>
    unsafe public void Read(BinaryReader reader)
    {
      hdr.Read(reader, this);
      long oldPos = reader.BaseStream.Position;

      // Offset field in the stream header is relataive to
      // the start of metadata.
      reader.BaseStream.Position = root.filePos + hdr.offs;
      data = reader.ReadBytes((int) hdr.size);

      // set reader's position to the first byte after
      // stream header.
      reader.BaseStream.Position = oldPos;
    }


    public void Write (BinaryWriter writer)
    {
      hdr.Write (writer, this);
      long old_pos = writer.BaseStream.Position;
      writer.BaseStream.Position = root.filePos + hdr.offs;
      writer.Write (data);
      writer.BaseStream.Position = old_pos;
    }

    /// <summary>
    /// Initializes heap for this stream.
    /// </summary>
    protected void InitHeap()
    {
      heap = MDHeap.Create(this);
    }


    /// <summary>
    /// </summary>
    public void Dump(TextWriter writer) {
      string dump = String.Format(
        "Name        : {0}" + Environment.NewLine +
        "Offset      : 0x{1:x8}" + Environment.NewLine +
        "Size        : 0x{2:x8}" + Environment.NewLine,
        hdr.name, hdr.offs, hdr.size
      );
      writer.WriteLine(dump);
    }


    /// <summary>
    /// </summary>
    public override string ToString()
    {
      StringWriter sw = new StringWriter ();
      Dump(sw);
      return sw.ToString();
    }

  }
}