context: using System;
  using System.IO;
  using System.Collections;
  using System.Text;
  
  namespace PEAPI {
  
  	/**************************************************************************/  
  	/// <summary>
  	/// Image for a PEFile
  	/// File Structure
  	///     DOS Header (128 bytes) 
  	///     PE Signature ("PE\0\0") 
  	///     PEFileHeader (20 bytes)
  	///     PEOptionalHeader (224 bytes) 
  	///     SectionHeaders (40 bytes * NumSections)
  	///
  	///     Sections .text (always present - contains metadata)
  	///              .sdata (contains any initialised data in the file - may not be present)
  	///                     (for ilams /debug this contains the Debug table)
  	///              .reloc (always present - in pure CIL only has one fixup)
  	///               others???  c# produces .rsrc section containing a Resource Table
  	///
  	/// .text layout
  	///     IAT (single entry 8 bytes for pure CIL)
  	///     CLIHeader (72 bytes)
  	///     CIL instructions for all methods (variable size)
  	///     MetaData 
  	///       Root (20 bytes + UTF-8 Version String + quad align padding)
  	///       StreamHeaders (8 bytes + null terminated name string + quad align padding)
  	///       Streams 
  	///         #~        (always present - holds metadata tables)
  	///         #Strings  (always present - holds identifier strings)
  	///         #US       (Userstring heap)
  	///         #Blob     (signature blobs)
  	///         #GUID     (guids for assemblies or Modules)
  	///    ImportTable (40 bytes)
  	///    ImportLookupTable(8 bytes) (same as IAT for standard CIL files)
  	///    Hint/Name Tables with entry "_CorExeMain" for .exe file and "_CorDllMain" for .dll (14 bytes)
  	///    ASCII string "mscoree.dll" referenced in ImportTable (+ padding = 16 bytes)
  	///    Entry Point  (0xFF25 followed by 4 bytes 0x400000 + RVA of .text)
  	///
  	///  #~ stream structure
  	///    Header (24 bytes)
  	///    Rows   (4 bytes * numTables)
  	///    Tables
  	/// </summary>
  	internal class FileImage : BinaryWriter {
  
  		internal readonly static uint[] iByteMask = {0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000};
  		internal readonly static ulong[] lByteMask = {0x00000000000000FF, 0x000000000000FF00,
  			0x0000000000FF0000, 0x00000000FF000000,
  			0x000000FF00000000, 0x0000FF0000000000,
  			0x00FF000000000000, 0xFF00000000000000 };
  		internal readonly static uint nibble0Mask = 0x0000000F;
  		internal readonly static uint nibble1Mask = 0x000000F0;
  
  		private static readonly byte[] DOSHeader = { 0x4d,0x5a,0x90,0x00,0x03,0x00,0x00,0x00,
  			0x04,0x00,0x00,0x00,0xff,0xff,0x00,0x00,
  			0xb8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  			0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  			0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  			0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  			0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  			0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,
  			0x0e,0x1f,0xba,0x0e,0x00,0xb4,0x09,0xcd,
  			0x21,0xb8,0x01,0x4c,0xcd,0x21,0x54,0x68,
  			0x69,0x73,0x20,0x70,0x72,0x6f,0x67,0x72,
  			0x61,0x6d,0x20,0x63,0x61,0x6e,0x6e,0x6f,
  			0x74,0x20,0x62,0x65,0x20,0x72,0x75,0x6e,
  			0x20,0x69,0x6e,0x20,0x44,0x4f,0x53,0x20,
  			0x6d,0x6f,0x64,0x65,0x2e,0x0d,0x0d,0x0a,
  			0x24,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  			0x50,0x45,0x00,0x00};
  		private static byte[] PEHeader = { 0x4c, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  			0xE0, 0x00, 0x0E, 0x01, // PE Header Standard Fields
  			0x0B, 0x01, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 
  			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  		};
  
  		private static readonly uint minFileAlign = 0x200;
  		private static readonly uint maxFileAlign = 0x1000;
  		private static readonly uint fileHeaderSize = 0x178;
  		private static readonly uint sectionHeaderSize = 40;
  		private static readonly uint SectionAlignment = 0x2000;
  		private static readonly uint ImageBase = 0x400000;
  		private static readonly uint ImportTableSize = 40;
  		private static readonly uint IATSize = 8;
  		private static readonly uint CLIHeaderSize = 72;
  		private uint runtimeFlags = 0x01;  // COMIMAGE_FLAGS_ILONLY
  		// 32BITREQUIRED 0x02, STRONGNAMESIGNED 0x08, TRACKDEBUGDATA 0x10000
  		private static readonly uint StrongNameSignatureSize = 128;
  		private bool reserveStrongNameSignatureSpace = false;
  
  		private static readonly uint relocFlags = 0x42000040;
  		private static readonly ushort exeCharacteristics = 0x010E;
  		private static readonly ushort dllCharacteristics = 0x210E;
  		// section names are all 8 bytes
  		private static readonly string textName = ".text\0\0\0";
  		private static readonly string sdataName = ".sdata\0\0";
  		private static readonly string relocName = ".reloc\0\0";
  		private static readonly string rsrcName = ".rsrc\0\0\0";
  		private static readonly string exeHintNameTable = "\0\0_CorExeMain\0";
  		private static readonly string dllHintNameTable = "\0\0_CorDllMain\0";
  		private static readonly string runtimeEngineName = "mscoree.dll\0\0";
  
  		private Section text, sdata, rsrc;
  		ArrayList data;
  		BinaryWriter reloc = new BinaryWriter(new MemoryStream());
  		uint dateStamp = 0;
  		DateTime origin = new DateTime(1970,1,1);
  		uint numSections = 2; // always have .text  and .reloc sections
  		internal SubSystem subSys = SubSystem.Windows_CUI;  // default is Windows Console mode
  		internal long stackReserve = 0x100000; // default is 1Mb 
  		internal uint fileAlign = minFileAlign;
  		uint entryPointOffset, entryPointPadding, imageSize, headerSize, headerPadding, entryPointToken = 0;
  		uint relocOffset, relocRVA, relocSize, relocPadding, relocTide, hintNameTableOffset;
  		uint metaDataOffset, runtimeEngineOffset, initDataSize = 0, importTablePadding;
  		uint resourcesSize, resourcesOffset;
  		uint strongNameSigOffset;
  		uint importTableOffset, importLookupTableOffset, totalImportTableSize;
  		MetaData metaData;
  		char[] runtimeEngine = runtimeEngineName.ToCharArray(), hintNameTable;
  		bool doDLL, largeStrings, largeGUID, largeUS, largeBlob;
  		ushort characteristics;
  
  		internal FileImage(bool makeDLL, string fileName) : base(new FileStream(fileName,FileMode.Create)) 
  		{
  			InitFileImage(makeDLL);
  			TimeSpan tmp = System.IO.File.GetCreationTime(fileName).Subtract(origin);
  			dateStamp = Convert.ToUInt32(tmp.TotalSeconds);
  		}
  
  		internal FileImage(bool makeDLL, Stream str) : base(str) 
  		{
  			InitFileImage(makeDLL);
  			TimeSpan tmp = DateTime.Now.Subtract(origin);
  			dateStamp = Convert.ToUInt32(tmp.TotalSeconds);
  		}
  
  		private void InitFileImage(bool makeDLL) 
  		{
  			doDLL = makeDLL;
  			if (doDLL) {
  				hintNameTable = dllHintNameTable.ToCharArray();
  				characteristics = dllCharacteristics;
  			} else {
  				hintNameTable = exeHintNameTable.ToCharArray();
  				characteristics = exeCharacteristics;
  			}
  			text = new Section(textName,0x60000020);     // IMAGE_SCN_CNT  CODE, EXECUTE, READ
  			//                      rsrc = new Section(rsrcName,0x40000040);     // IMAGE_SCN_CNT  INITIALIZED_DATA, READ
  			metaData = new MetaData(this);
  		}
  
  		internal MetaData GetMetaData() 
  		{
  			return metaData;
  		}
  
  		private uint GetNextSectStart(uint rva, uint tide) 
  		{
  			uint c = tide / SectionAlignment;
  			if ((tide % SectionAlignment) != 0)
  				c++;
  			return rva + (c * SectionAlignment);
  		}
  
  		private void BuildTextSection() 
  		{
  			// .text layout
  			//    IAT (single entry 8 bytes for pure CIL)
  			//    CLIHeader (72 bytes)
  			//    CIL instructions for all methods (variable size)
  			//    MetaData 
  			//    ImportTable (40 bytes)
  			//    ImportLookupTable(8 bytes) (same as IAT for standard CIL files)
  			//    Hint/Name Tables with entry "_CorExeMain" for .exe file and "_CorDllMain" for .dll (14 bytes)
  			//    ASCII string "mscoree.dll" referenced in ImportTable (+ padding = 16 bytes)
  			//    Entry Point  (0xFF25 followed by 4 bytes 0x400000 + RVA of .text)
  			metaData.BuildMetaData(IATSize + CLIHeaderSize);
  			metaDataOffset = IATSize + CLIHeaderSize;
  			// Console.WriteLine("Code starts at " + metaDataOffset);
  			metaDataOffset += metaData.CodeSize();
  			// resourcesStart =
  			resourcesOffset = metaDataOffset + metaData.Size ();
  			resourcesSize = metaData.GetResourcesSize ();
  			if (reserveStrongNameSignatureSpace) {
  				strongNameSigOffset = resourcesOffset + resourcesSize;
  				// fixUps = RVA for vtable
  				importTableOffset = strongNameSigOffset + StrongNameSignatureSize;
  			} else {
  				strongNameSigOffset = 0;
  				// fixUps = RVA for vtable
  				importTableOffset = resourcesOffset + resourcesSize;
  			}
  			importTablePadding = NumToAlign(importTableOffset,16);
  			importTableOffset += importTablePadding;
  			importLookupTableOffset = importTableOffset + ImportTableSize;
  			hintNameTableOffset = importLookupTableOffset + IATSize;
  			runtimeEngineOffset = hintNameTableOffset + (uint)hintNameTable.Length;
  			entryPointOffset = runtimeEngineOffset + (uint)runtimeEngine.Length;
  			totalImportTableSize = entryPointOffset - importTableOffset;
  			// Console.WriteLine("total import table size = " + totalImportTableSize);
  			// Console.WriteLine("entrypoint offset = " + entryPointOffset);
  			entryPointPadding = NumToAlign(entryPointOffset,4) + 2;
  			entryPointOffset += entryPointPadding;
  			text.AddReloc(entryPointOffset+2);
  			text.IncTide(entryPointOffset + 6);
  			//if (text.Tide() < fileAlign) fileAlign = minFileAlign;
  			text.SetSize(NumToAlign(text.Tide(),fileAlign));
  			// Console.WriteLine("text size = " + text.Size() + " text tide = " + text.Tide() + " text padding = " + text.Padding());
  			// Console.WriteLine("metaDataOffset = " + Hex.Int(metaDataOffset));
  			// Console.WriteLine("importTableOffset = " + Hex.Int(importTableOffset));
  			// Console.WriteLine("importLookupTableOffset = " + Hex.Int(importLookupTableOffset));
  			// Console.WriteLine("hintNameTableOffset = " + Hex.Int(hintNameTableOffset));
  			// Console.WriteLine("runtimeEngineOffset = " + Hex.Int(runtimeEngineOffset));
  			// Console.WriteLine("entryPointOffset = " + Hex.Int(entryPointOffset));
  			// Console.WriteLine("entryPointPadding = " + Hex.Int(entryPointPadding));
  
  		}
  
  		internal void BuildRelocSection() 
  		{
  			text.DoRelocs(reloc);
  			if (sdata != null) sdata.DoRelocs(reloc);
  			if (rsrc != null) rsrc.DoRelocs(reloc);
  			relocTide = (uint)reloc.Seek(0,SeekOrigin.Current);
  			relocPadding = NumToAlign(relocTide,fileAlign);
  			relocSize = relocTide + relocPadding;
  			imageSize = relocRVA + SectionAlignment;
  			initDataSize += relocSize;
  		}
  
  		private void CalcOffsets() 
  		{
  			if (sdata != null)
  				numSections++;
  			if (rsrc != null)
  				numSections++;
  			headerSize = fileHeaderSize + (numSections * sectionHeaderSize);
  			headerPadding = NumToAlign(headerSize,fileAlign);
  			headerSize += headerPadding;
  			uint offset = headerSize;
  			uint rva = SectionAlignment;
  			text.SetOffset(offset);
  			text.SetRVA(rva);
  			offset += text.Size();
  			rva  = GetNextSectStart(rva,text.Tide());
  			// Console.WriteLine("headerSize = " + headerSize);
  			// Console.WriteLine("headerPadding = " + headerPadding);
  			// Console.WriteLine("textOffset = " + Hex.Int(text.Offset()));
  			if (sdata != null) { 
  				sdata.SetSize(NumToAlign(sdata.Tide(),fileAlign));
  				sdata.SetOffset(offset);
  				sdata.SetRVA(rva);
  				offset += sdata.Size();
  				rva = GetNextSectStart(rva,sdata.Tide());
  				initDataSize += sdata.Size();
  			}
  			if (rsrc != null) { 
  				rsrc.SetSize(NumToAlign(rsrc.Tide(),fileAlign));
  				rsrc.SetOffset(offset);
  				rsrc.SetRVA(rva);
  				offset += rsrc.Size();
  				rva = GetNextSectStart(rva,rsrc.Tide());
  				initDataSize += rsrc.Size();
  			}
  			relocOffset = offset;
  			relocRVA = rva;
  		}
  
  		internal void MakeFile() 
  		{
  			if (doDLL) hintNameTable = dllHintNameTable.ToCharArray();
  			else hintNameTable = exeHintNameTable.ToCharArray();
  			BuildTextSection();
  			CalcOffsets();
  			BuildRelocSection();
  			// now write it out
  			WriteHeader();
  			WriteSections();
  			Flush();
  			Close();
  		}
  
  		private void WriteHeader() 
  		{
  			Write(DOSHeader);
  			// Console.WriteLine("Writing PEHeader at offset " + Seek(0,SeekOrigin.Current));
  			WritePEHeader();
  			// Console.WriteLine("Writing text section header at offset " + Hex.Long(Seek(0,SeekOrigin.Current)));
  			text.WriteHeader(this,relocRVA);
  			if (sdata != null) sdata.WriteHeader(this,relocRVA);
  			if (rsrc != null) rsrc.WriteHeader(this,relocRVA);
  			// Console.WriteLine("Writing reloc section header at offset " + Seek(0,SeekOrigin.Current));
  			WriteRelocSectionHeader();
  			// Console.WriteLine("Writing padding at offset " + Seek(0,SeekOrigin.Current));
  			WriteZeros(headerPadding);
  		}
  
  		private void WriteSections() 
  		{
  			// Console.WriteLine("Writing text section at offset " + Seek(0,SeekOrigin.Current));
  			WriteTextSection();
  			if (sdata != null) WriteSDataSection();
  			if (rsrc != null) WriteRsrcSection();
  			WriteRelocSection();
  		}
  
  		private void WriteIAT() 
  		{
  			Write(text.RVA() + hintNameTableOffset);
  			Write(0);
  		}
  
  		private void WriteImportTables() 
  		{
  			// Import Table
  			WriteZeros(importTablePadding);
  			// Console.WriteLine("Writing import tables at offset " + Hex.Long(Seek(0,SeekOrigin.Current)));
  			Write(importLookupTableOffset + text.RVA());
  			WriteZeros(8); 
  			Write(runtimeEngineOffset + text.RVA());
  			Write(text.RVA());    // IAT is at the beginning of the text section
  			WriteZeros(20);
  			// Import Lookup Table
  			WriteIAT();                // lookup table and IAT are the same
  			// Hint/Name Table
  			// Console.WriteLine("Writing hintname table at " + Hex.Long(Seek(0,SeekOrigin.Current)));
  			Write(hintNameTable);
  			Write(runtimeEngineName.ToCharArray());
  		}
  
  		private void WriteTextSection() 
  		{
  			WriteIAT();
  			WriteCLIHeader();
  			// Console.WriteLine("Writing code at " + Hex.Long(Seek(0,SeekOrigin.Current)));
  			metaData.WriteByteCodes(this);
  			// Console.WriteLine("Finished writing code at " + Hex.Long(Seek(0,SeekOrigin.Current)));
  			largeStrings = metaData.LargeStringsIndex();
  			largeGUID = metaData.LargeGUIDIndex();
  			largeUS = metaData.LargeUSIndex();
  			largeBlob = metaData.LargeBlobIndex();
  			metaData.WriteMetaData(this);
  			metaData.WriteResources (this);
  			if (reserveStrongNameSignatureSpace) {
  				WriteZeros(StrongNameSignatureSize);
  			}
  			WriteImportTables();
  			WriteZeros(entryPointPadding);
  			Write((ushort)0x25FF);
  			Write(ImageBase + text.RVA());
  			WriteZeros(text.Padding());
  		}
  
  		private void WriteCLIHeader() 
  		{
  			Write(CLIHeaderSize);       // Cb
  			Write((short)2);            // Major runtime version
  			Write((short)0);            // Minor runtime version
  			Write(text.RVA() + metaDataOffset);
  			Write(metaData.Size());
  			Write(runtimeFlags);
  			Write(entryPointToken);
  			if (resourcesSize > 0) {
  				Write (text.RVA () + resourcesOffset);
  				Write (resourcesSize);
  			} else {
  				WriteZeros (8);
  			}
  			// Strong Name Signature (RVA, size)
  			if (reserveStrongNameSignatureSpace) {
  				Write(text.RVA() + strongNameSigOffset); 
  				Write(StrongNameSignatureSize);
  			} else {
  				WriteZeros(8);
  			}
  			WriteZeros(8);                     // CodeManagerTable
  			WriteZeros(8);                     // VTableFixups NYI
  			WriteZeros(16);                    // ExportAddressTableJumps, ManagedNativeHeader
  		}
  
  		private void WriteSDataSection() 
  		{
  			long size = sdata.Size ();
  			long start = BaseStream.Position;
  			for (int i=0; i < data.Count; i++) {
  				((DataConstant)data[i]).Write(this);
  			}
  			while (BaseStream.Position < (start + size))
  				Write ((byte) 0);
  		}
  
  		private void WriteRsrcSection() 
  		{
  		}
  
  		private void WriteRelocSection() 
  		{
  			// Console.WriteLine("Writing reloc section at " + Seek(0,SeekOrigin.Current) + " = " + relocOffset);
  			MemoryStream str = (MemoryStream)reloc.BaseStream;
  			Write(str.ToArray());
  			WriteZeros(NumToAlign((uint)str.Position,fileAlign));
  		}
  
  		internal void SetEntryPoint(uint entryPoint) 
  		{
  			entryPointToken = entryPoint;
  		}
  
  		internal void AddInitData(DataConstant cVal) 
  		{
  			if (sdata == null) {                    
  				sdata = new Section(sdataName,0xC0000040);   // IMAGE_SCN_CNT  INITIALIZED_DATA, READ, WRITE
  				data = new ArrayList(); 
  			}
  			data.Add(cVal);
  			cVal.DataOffset = sdata.Tide();
  			sdata.IncTide(cVal.GetSize());
  		}
  
  		internal void WriteZeros(uint numZeros) 
  		{
  			for (int i=0; i < numZeros; i++) {
  				Write((byte)0);
  			}
  		}
  
  		internal void WritePEHeader() 
  		{
  			Write((ushort)0x014C);  // Machine - always 0x14C for Managed PE Files (allow others??)
  			Write((ushort)numSections);
  			Write(dateStamp);
  			WriteZeros(8); // Pointer to Symbol Table and Number of Symbols (always zero for ECMA CLI files)
  			Write((ushort)0x00E0);  // Size of Optional Header
  			Write(characteristics);
  			// PE Optional Header
  			Write((ushort)0x010B);   // Magic
  			Write((byte)0x6);        // LMajor pure-IL = 6   C++ = 7
  			Write((byte)0x0);        // LMinor
  			Write(text.Size());
  			Write(initDataSize);
  			Write(0);                // Check other sections here!!
  			Write(text.RVA() + entryPointOffset);
  			Write(text.RVA());
  			uint dataBase = 0;
  			if (sdata != null) dataBase = sdata.RVA();
  			else if (rsrc != null) dataBase = rsrc.RVA();
  			else dataBase = relocRVA;
  			Write(dataBase);
  			Write(ImageBase);
  			Write(SectionAlignment);
  			Write(fileAlign);
  			Write((ushort)0x04);     // OS Major
  			WriteZeros(6);                  // OS Minor, User Major, User Minor
  			Write((ushort)0x04);     // SubSys Major
  			WriteZeros(6);           // SybSys Minor, Reserved
  			Write(imageSize);
  			Write(headerSize);
  			Write((int)0);           // File Checksum
  			Write((ushort)subSys);
  			Write((short)0);         // DLL Flags
  			Write((uint)stackReserve);   // Stack Reserve Size
  			Write((uint)0x1000);     // Stack Commit Size
  			Write((uint)0x100000);   // Heap Reserve Size
  			Write((uint)0x1000);     // Heap Commit Size
  			Write(0);                // Loader Flags
  			Write(0x10);             // Number of Data Directories
  			WriteZeros(8);                  // Export Table
  			Write(importTableOffset + text.RVA());
  			Write(totalImportTableSize);
  			WriteZeros(24);            // Resource, Exception and Certificate Tables
  			Write(relocRVA);
  			Write(relocTide);
  			WriteZeros(48);            // Debug, Copyright, Global Ptr, TLS, Load Config and Bound Import Tables
  			Write(text.RVA());         // IATRVA - IAT is at start of .text Section
  			Write(IATSize);
  			WriteZeros(8);             // Delay Import Descriptor
  			Write(text.RVA()+IATSize); // CLIHeader immediately follows IAT
  			Write(CLIHeaderSize);    
  			WriteZeros(8);             // Reserved
  		}
  
  		internal void WriteRelocSectionHeader() 
  		{
  			Write(relocName.ToCharArray());
  			Write(relocTide);
  			Write(relocRVA);
  			Write(relocSize);
  			Write(relocOffset);
  			WriteZeros(12);
  			Write(relocFlags);
  		}
  
  		private void Align (MemoryStream str, int val) 
  		{
  			if ((str.Position % val) != 0) {
  				for (int i=val - (int)(str.Position % val); i > 0; i--) {
  					str.WriteByte(0);
  				}
  			}
  		}
  
  		private uint Align(uint val, uint alignVal) 
  		{
  			if ((val % alignVal) != 0) {
  				val += alignVal - (val % alignVal);
  			}
  			return val;
  		}
  
  		private uint NumToAlign(uint val, uint alignVal) 
  		{
  			if ((val % alignVal) == 0) return 0;
  			return alignVal - (val % alignVal);
  		}
  
  		internal void StringsIndex(uint ix) 
  		{
  			if (largeStrings) Write(ix);
  			else Write((ushort)ix);
  		}
  
  		internal void GUIDIndex(uint ix) 
  		{
  			if (largeGUID) Write(ix);
  			else Write((ushort)ix);
  		}
  
  		internal void USIndex(uint ix) 
  		{
  			if (largeUS) Write(ix);
  			else Write((ushort)ix);
  		}
  
  		internal void BlobIndex(uint ix) 
  		{
  			if (largeBlob) Write(ix);
  			else Write((ushort)ix);
  		}
  
  		internal void WriteIndex(MDTable tabIx,uint ix) 
  		{
  			if (metaData.LargeIx(tabIx)) Write(ix);
  			else Write((ushort)ix);
  		}
  
  		internal void WriteCodedIndex(CIx code, MetaDataElement elem) 
  		{
  			metaData.WriteCodedIndex(code,elem,this);
  		}
  
  		internal void WriteCodeRVA(uint offs) 
  		{
  			Write(text.RVA() + offs);
  		}
  
  		internal void WriteDataRVA(uint offs) 
  		{
  			Write(sdata.RVA() + offs);
  		}
  
  		internal void Write3Bytes(uint val) 
  		{
  			byte b3 = (byte)((val & FileImage.iByteMask[2]) >> 16);
  			byte b2 = (byte)((val & FileImage.iByteMask[1]) >> 8);;
  			byte b1 = (byte)(val & FileImage.iByteMask[0]);
  			Write(b1);
  			Write(b2);
  			Write(b3);
  		}
  
  		internal bool ReserveStrongNameSignatureSpace {
  			get { return reserveStrongNameSignatureSpace; }
  			set { reserveStrongNameSignatureSpace = value; }
  		}
  
  	}
  
  	/**************************************************************************/  
  	/// <summary>
  	/// Base class for the PEFile (starting point)
  	/// </summary>
  	public class PEFile {
  
  		private static readonly string mscorlibName = "mscorlib";
  		private Module thisMod;
  		private ClassDef moduleClass;
  		private ArrayList resources = new ArrayList ();
  		private Assembly thisAssembly;
  		private static bool isMSCorlib;
  		private int corFlags = 1;
  		FileImage fileImage;
  		MetaData metaData;
  
  		/// <summary>
  		/// Create a new PEFile.  Each PEFile is a module.
  		/// </summary>
  		/// <param name="name">module name, also used for the file name</param>
  		/// <param name="isDLL">create a .dll or .exe file</param>
  		/// <param name="hasAssembly">this file is an assembly and 
  		/// will contain the assembly manifest.  The assembly name is the 
  		/// same as the module name</param>
  		public PEFile(string name, bool isDLL, bool hasAssembly)
  			: this (name, null, isDLL, hasAssembly, null, null) 
  		{
  			// Console.WriteLine(Hex.Byte(0x12));
  			// Console.WriteLine(Hex.Short(0x1234));
  			// Console.WriteLine(Hex.Int(0x12345678));
  		}
  
  		/// <summary>
  		/// Create a new PEFile.  Each PEFile is a module.
  		/// </summary>
  		/// <param name="name">module name, also used for the file name</param>
  		/// <param name="isDLL">create a .dll or .exe file</param>
  		/// <param name="hasAssembly">this file is an assembly and 
  		/// will contain the assembly manifest.  The assembly name is the 
  		/// same as the module name</param>
  		/// <param name="outputDir">write the PEFile to this directory.  If this
  		/// string is null then the output will be to the current directory</param>
  		public PEFile(string name, bool isDLL, bool hasAssembly, string outputDir)
  			: this (name, null, isDLL, hasAssembly, outputDir, null) 
  		{
  			// Console.WriteLine(Hex.Byte(0x12));
  			// Console.WriteLine(Hex.Short(0x1234));
  			// Console.WriteLine(Hex.Int(0x12345678));
  		}
  
  		/// <summary>
  		/// Create a new PEFile
  		/// </summary>
  		/// <param name="name">module name</param>
  		/// <param name="isDLL">create a .dll or .exe</param>
  		/// <param name="hasAssembly">this PEfile is an assembly and
  		/// will contain the assemly manifest.  The assembly name is the
  		/// same as the module name</param>
  		/// <param name="outStream">write the PEFile to this stream instead
  		/// of to a new file</param>
  		public PEFile(string name, bool isDLL, bool hasAssembly, Stream outStream)
  			: this (name, null, isDLL, hasAssembly, null, outStream) 
  		{
  		}
  
  		public PEFile(string name, string module_name, bool isDLL, bool hasAssembly, Stream outStream)
  			: this (name, module_name, isDLL, hasAssembly, null, outStream) 
  		{
  		}  
  
  		public PEFile(string name, string module_name, bool isDLL, bool hasAssembly, string outputDir, Stream outStream) 
  		{
  			SetName (name);
  			string fname = module_name == null ? MakeFileName (outputDir, name, isDLL) : module_name;
  			if (outStream == null)
  				fileImage = new FileImage (isDLL, fname);
  			else  
  				fileImage = new FileImage (isDLL, outStream);
  
  			InitPEFile (name, fname, hasAssembly);
  		}
  
  		private void SetName (string name)
  		{
  			if (name == "mscorlib")
  				isMSCorlib = true;
  		}
  
  		private void InitPEFile(string name, string fName, bool hasAssembly) 
  		{
  			metaData = fileImage.GetMetaData();
  			thisMod = new Module(fName,metaData);
  			if (hasAssembly) {
  				thisAssembly = new Assembly(name,metaData);
  				metaData.AddToTable(MDTable.Assembly,thisAssembly);      
  			}
  			moduleClass = AddClass(TypeAttr.Private,"","<Module>");
  			moduleClass.SpecialNoSuper();
  			metaData.AddToTable(MDTable.Module,thisMod);
  		}
  
  		internal static bool IsMSCorlib {
  			get { return isMSCorlib; }
  		}
  
  		public ClassDef ModuleClass {
  			get { return moduleClass; }
  		}
  
  		/// <summary>
  		/// Set the subsystem (.subsystem) (Default is Windows Console mode)
  		/// </summary>
  		/// <param name="subS">subsystem value</param>
  		public void SetSubSystem(SubSystem subS) 
  		{
  			fileImage.subSys = subS;
  		}
  
  		/// <summary>
  		/// Set the flags (.corflags)
  		/// </summary>
  		/// <param name="flags">the flags value</param>
  		public void SetCorFlags(int flags) 
  		{
  			corFlags = flags;
  		}
  
  		public void SetStackReserve (long stackReserve)
  		{
  			fileImage.stackReserve = stackReserve;
  		}
  
  		private string MakeFileName(string dirName, string name, bool isDLL) 
  		{
  			string result = "";
  			if ((dirName != null) && (dirName.CompareTo("") != 0)) {
  				result = dirName;
  				if (!dirName.EndsWith("\\")) result += "\\";
  			}
  			result += name;
  
  			// if (isDLL) result += ".dll";  else result += ".exe";
  
  			return result;
  		}
  
  		/// <summary>
  		/// Add an external assembly to this PEFile (.assembly extern)
  		/// </summary>
  		/// <param name="assemName">the external assembly name</param>
  		/// <returns>a descriptor for this external assembly</returns>
  		public AssemblyRef AddExternAssembly(string assemName) 
  		{
  			if (assemName.CompareTo(mscorlibName) == 0) return metaData.mscorlib;
  			AssemblyRef anAssem = new AssemblyRef(metaData,assemName);
  			metaData.AddToTable(MDTable.AssemblyRef,anAssem);
  			// Console.WriteLine("Adding assembly " + assemName);
  			return anAssem;
  		}
  
  		/// <summary>
  		/// Add an external module to this PEFile (.module extern)
  		/// </summary>
  		/// <param name="name">the external module name</param>
  		/// <returns>a descriptor for this external module</returns>
  		public ModuleRef AddExternModule(string name) 
  		{
  			ModuleRef modRef = new ModuleRef(metaData,name);
  			metaData.AddToTable(MDTable.ModuleRef,modRef);
  			return modRef;
  		}
  
  		public ClassRef AddExternClass(string ns, string name, TypeAttr attrs, MetaDataElement declRef)
  		{
  			return new ExternClassRef (attrs, ns, name, declRef, metaData);
  		}
  		
  		/// <summary>
  		/// Add a "global" method to this module
  		/// </summary>
  		/// <param name="name">method name</param>
  		/// <param name="retType">return type</param>
  		/// <param name="pars">method parameters</param>
  		/// <returns>a descriptor for this new "global" method</returns>
  		public MethodDef AddMethod (string name, Param ret_param, Param [] pars) 
  		{
  			return moduleClass.AddMethod (name, ret_param, pars);
  		}
  		
  		public MethodDef AddMethod(string name, Type retType, Param[] pars) 
  		{
  			return AddMethod (name, new Param (ParamAttr.Default, "", retType), pars);
  		}
  
  		/// <summary>
  		/// Add a "global" method to this module
  		/// </summary>
  		/// <param name="mAtts">method attributes</param>
  		/// <param name="iAtts">method implementation attributes</param>
  		/// <param name="name">method name</param>
  		/// <param name="retType">return type</param>
  		/// <param name="pars">method parameters</param>
  		/// <returns>a descriptor for this new "global" method</returns>
  		public MethodDef AddMethod (MethAttr mAtts, ImplAttr iAtts, string name, Param ret_param, Param [] pars) 
  		{
  			return moduleClass.AddMethod (mAtts, iAtts, name, ret_param, pars);
  		}
  
  		public MethodDef AddMethod(MethAttr mAtts, ImplAttr iAtts, string name, Type retType, Param[] pars) 
  		{
  			return AddMethod (mAtts, iAtts, name, new Param (ParamAttr.Default, "", retType), pars);
  		}
  
  		public MethodRef AddMethodToTypeSpec (Type item, string name, Type retType, Type[] pars) 
  		{
  			return AddMethodToTypeSpec (item, name, retType, pars, 0);
  		}
  		
  		public MethodRef AddMethodToTypeSpec (Type item, string name, Type retType, Type[] pars, int gen_param_count) 
  		{
  			MethodRef meth = new MethodRef (item.GetTypeSpec (metaData), name, retType, pars, false, null, gen_param_count);
  			metaData.AddToTable (MDTable.MemberRef,meth);
  			return meth;
  		}
  
  		public MethodRef AddVarArgMethodToTypeSpec (Type item, string name, Type retType,
  				Type[] pars, Type[] optPars) {
  			MethodRef meth = new MethodRef(item.GetTypeSpec (metaData), name,retType,pars,true,optPars, 0);
  			metaData.AddToTable(MDTable.MemberRef,meth);
  			return meth;
  		}
  
  		public FieldRef AddFieldToTypeSpec (Type item, string name, Type fType) 
  		{
  			FieldRef field = new FieldRef (item.GetTypeSpec (metaData), name,fType);
  			metaData.AddToTable (MDTable.MemberRef,field);
  			return field;
  		}
  
  		public Method AddMethodSpec (Method m, GenericMethodSig g_sig)
  		{
  			MethodSpec ms = new MethodSpec (m, g_sig);
  			metaData.AddToTable (MDTable.MethodSpec, ms);
  			return ms;
  		}
  
  		/// <summary>
  		/// Add a "global" field to this module
  		/// </summary>
  		/// <param name="name">field name</param>
  		/// <param name="fType">field type</param>
  		/// <returns>a descriptor for this new "global" field</returns>
  		public FieldDef AddField(string name, Type fType) 
  		{
  			return moduleClass.AddField(name,fType);
  		}
  
  		/// <summary>
  		/// Add a "global" field to this module
  		/// </summary>
  		/// <param name="attrSet">attributes of this field</param>
  		/// <param name="name">field name</param>
  		/// <param name="fType">field type</param>
  		/// <returns>a descriptor for this new "global" field</returns>
  		public FieldDef AddField(FieldAttr attrSet, string name, Type fType) 
  		{
  			return moduleClass.AddField(attrSet,name,fType);
  		}
  
  		/// <summary>
  		/// Add a class to this module
  		/// </summary>
  		/// <param name="attrSet">attributes of this class</param>
  		/// <param name="nsName">name space name</param>
  		/// <param name="name">class name</param>
  		/// <returns>a descriptor for this new class</returns>
  		public ClassDef AddClass(TypeAttr attrSet, string nsName, string name) 
  		{
  			return AddClass (attrSet, nsName, name, null);
  		}
  
  		/// <summary>
  		/// Add a class which extends System.ValueType to this module
  		/// </summary>
  		/// <param name="attrSet">attributes of this class</param>
  		/// <param name="nsName">name space name</param>
  		/// <param name="name">class name</param>
  		/// <returns>a descriptor for this new class</returns>
  		public ClassDef AddValueClass(TypeAttr attrSet, string nsName, string name, ValueClass vClass) 
  		{
  			ClassDef aClass = new ClassDef(attrSet,nsName,name,metaData);
  			if (!ClassDef.IsValueType (nsName, name) && !ClassDef.IsEnum (nsName, name)) {
  				aClass.MakeValueClass(vClass);
  			} else {
  				if (ClassDef.IsEnum (nsName, name))
  					aClass.SetSuper (metaData.mscorlib.ValueType ());
  				else
  					aClass.SetSuper (metaData.mscorlib.GetSpecialSystemClass (PrimitiveType.Object));
  
  				metaData.mscorlib.SetSpecialSystemClass (nsName, name, aClass);
  			}
  			aClass.SetTypeIndex (PrimitiveType.ValueType.GetTypeIndex ());
  			metaData.AddToTable(MDTable.TypeDef,aClass);
  			return aClass;
  		}
  
  		/// <summary>
  		/// Add a class to this module
  		/// </summary>
  		/// <param name="attrSet">attributes of this class</param>
  		/// <param name="nsName">name space name</param>
  		/// <param name="name">class name</param>
  		/// <param name="superType">super type of this class (extends)</param>
  		/// <returns>a descriptor for this new class</returns>
  		public ClassDef AddClass(TypeAttr attrSet, string nsName, string name, Class superType) 
  		{
  			ClassDef aClass = new ClassDef(attrSet,nsName,name,metaData);
  			if (superType != null)
  				aClass.SetSuper(superType);
  			if (PEFile.IsMSCorlib)
  				metaData.mscorlib.SetSpecialSystemClass (nsName, name, aClass);
  			metaData.AddToTable(MDTable.TypeDef,aClass);
  			return aClass;
  		}
  
  		public void  AddGenericClass (GenericTypeInst gti)
  		{
  			metaData.AddToTable (MDTable.TypeSpec, gti);
  		}
  
  		public void AddGenericParam (GenParam param)
  		{
  			metaData.AddToTable (MDTable.TypeSpec, param);
  		}
  
  		public FileRef AddFile(string fName, byte[] hashBytes, bool hasMetaData, bool entryPoint) 
  		{
  			FileRef file = new FileRef(fName,hashBytes,hasMetaData,entryPoint,metaData);
  			metaData.AddToTable(MDTable.File,file);
  			return file;
  		}
  
  		public PrimitiveTypeRef AddPrimitiveType (PrimitiveType type)
  		{
  			return new PrimitiveTypeRef (type, metaData);
  		}
  
  		/// <summary>
  		/// Add a manifest resource to this PEFile NOT YET IMPLEMENTED
  		/// </summary>
  		/// <param name="mr"></param>
  		public void AddManifestResource(ManifestResource mr) 
  		{
  			metaData.AddToTable(MDTable.ManifestResource,mr);
  			resources.Add (mr);
  			//mr.FixName(metaData);
  		}
  
  		public void AddCustomAttribute (Method meth, byte [] data, MetaDataElement element)
  		{
  			metaData.AddCustomAttribute (new CustomAttribute (element, meth, data));
  			element.HasCustomAttr = true;
  		}
  
  		public void AddCustomAttribute (Method meth, Constant constant, MetaDataElement element)
  		{
  			metaData.AddCustomAttribute (new CustomAttribute (element, meth, constant));
  			element.HasCustomAttr = true;
  		}
  
  		public void AddDeclSecurity (SecurityAction sec_action, byte [] data, MetaDataElement element)
  		{
  			metaData.AddDeclSecurity (new DeclSecurity (element, (ushort) sec_action, data));
  		}
  
  		public void AddDeclSecurity (SecurityAction sec_action, PEAPI.PermissionSet ps, MetaDataElement element)
  		{
  			metaData.AddDeclSecurity (new DeclSecurity_20 (element, (ushort) sec_action, ps));
  		}
  
  		/// <summary>
  		/// Add a managed resource from another assembly.
  		/// </summary>
  		/// <param name="resName">The name of the resource</param>
  		/// <param name="assem">The assembly where the resource is</param>
  		/// <param name="isPublic">Access for the resource</param>
  		public void AddExternalManagedResource (string resName, AssemblyRef assem, uint flags) 
  		{
  			resources.Add (new ManifestResource (resName, flags, assem));
  		}
  
  		/// <summary>
  		/// Add a managed resource from another assembly.
  		/// </summary>
  		/// <param name="mr"></param>
  		/// <param name="isPublic"></param>
  		public void AddExternalManagedResource (ManifestResource mr) 
  		{
  			resources.Add (new ManifestResource (mr));
  		}
  		/// <summary>
  		/// Find a resource
  		/// </summary>
  		/// <param name="name">The name of the resource</param>
  		/// <returns>The resource with the name "name" or null </returns>
  		public ManifestResource GetResource (string name) 
  		{
  			for (int i = 0; i < resources.Count; i ++) {
  				if (((ManifestResource) resources [i]).Name == name)
  					return (ManifestResource) resources [i];
  			}
  			return null;
  		}
  
  		public ManifestResource [] GetResources() 
  		{
  			return (ManifestResource []) resources.ToArray (typeof (ManifestResource));
  		}
  
  		/// <summary>
  		/// Write out the PEFile (the "bake" function)
  		/// </summary>
  		public void WritePEFile() { /* the "bake" function */
  			if (thisAssembly != null)
  				fileImage.ReserveStrongNameSignatureSpace = thisAssembly.HasPublicKey;
  			fileImage.MakeFile();
  		}
  
  		/// <summary>
  		/// Get the descriptor of this module
  		/// </summary>
  		/// <returns>the descriptor for this module</returns>
  		public Module GetThisModule() 
  		{
  			return thisMod;
  		}
  
  		/// <summary>
  		/// Get the descriptor for this assembly.  The PEFile must have been
  		/// created with hasAssembly = true
  		/// </summary>
  		/// <returns>the descriptor for this assembly</returns>
  		public Assembly GetThisAssembly() 
  		{
  			return thisAssembly;
  		}
  
  	}
  
  	/**************************************************************************/  
  	/// <summary>
  	/// Descriptor for a Section in a PEFile  eg .text, .sdata
  	/// </summary>
  	internal class Section {
  		private static readonly uint relocPageSize = 4096;  // 4K pages for fixups
  
  		char[] name; 
  		uint offset = 0, tide = 0, size = 0, rva = 0, relocTide = 0;
  		//uint relocOff = 0;
  		uint flags = 0, padding = 0;
  		uint[] relocs; 
  
  		internal Section(string sName, uint sFlags) 
  		{
  			name = sName.ToCharArray();
  			flags = sFlags;
  		}
  
  		internal uint Tide() { return tide; }
  
  		internal void IncTide(uint incVal) { tide += incVal; }
  
  		internal uint Padding() { return padding; }
  
  		internal uint Size() { return size; }
  
  		internal void SetSize(uint pad) 
  		{
  			padding = pad;
  			size = tide + padding;
  		}
  
  		internal uint RVA() { return rva; }
  
  		internal void SetRVA(uint rva) { this.rva = rva; }
  
  		internal uint Offset() { return offset; }
  
  		internal void SetOffset(uint offs) { offset = offs; }
  
  		internal void DoBlock(BinaryWriter reloc, uint page, int start, int end) 
  		{
  			//Console.WriteLine("rva = " + rva + "  page = " + page);
  			reloc.Write(rva + page);
  			reloc.Write((uint)(((end-start+1)*2) + 8));
  			for (int j=start; j < end; j++) {
  				//Console.WriteLine("reloc offset = " + relocs[j]);
  				reloc.Write((ushort)((0x3 << 12) | (relocs[j] - page)));
  			}
  			reloc.Write((ushort)0);
  		}
  
  		internal void DoRelocs(BinaryWriter reloc) 
  		{
  			if (relocTide > 0) {
  				//relocOff = (uint)reloc.Seek(0,SeekOrigin.Current);
  				uint block = (relocs[0]/relocPageSize + 1) * relocPageSize;
  				int start = 0;
  				for (int i=1; i < relocTide; i++) {
  					if (relocs[i] >= block) {
  						DoBlock(reloc,block-relocPageSize,start,i);
  						start = i;
  						block = (relocs[i]/relocPageSize + 1) * relocPageSize;
  					}
  				}
  				DoBlock(reloc,block-relocPageSize,start,(int)relocTide);
  			}
  		}
  
  		internal void AddReloc(uint offs) 
  		{
  			int pos = 0;
  			if (relocs == null) {
  				relocs = new uint[5];
  			} else {
  				if (relocTide >= relocs.Length) {
  					uint[] tmp = relocs;
  					relocs = new uint[tmp.Length + 5];
  					for (int i=0; i < relocTide; i++) {
  
gt: 						relocs[i] = tmp[i];