public TypeSignatureException(string msg) : base(msg) { }\r
}\r
\r
- public class GenericTypeSpec : Type {\r
+ public class ClassRefInst : Type {\r
+
+ private Class type;
+ private bool is_value;
+\r
+ public ClassRefInst (Class type, bool is_value) : base (0x12) {\r
+ this.type = type;
+ this.is_value = is_value;
+ if (is_value)
+ typeIndex = 0x11;
+ tabIx = MDTable.TypeSpec;\r
+ }\r
+\r
+ internal sealed override void TypeSig(MemoryStream str) {\r
+ str.WriteByte (GetTypeIndex());
+ MetaData.CompressNum (type.TypeDefOrRefToken(), str);\r
+ }
+ }\r
+
+ public class MVar : Type {\r
\r
private int index;\r
\r
- public GenericTypeSpec (int index) : base (0x13) {\r
+ public MVar (int index) : base (0x1E) {\r
this.index = index;\r
tabIx = MDTable.TypeSpec;\r
}\r
str.WriteByte(typeIndex);\r
MetaData.CompressNum ((uint) index, str);\r
}\r
+ }\r
+\r
+ public class GenericTypeSpec : Type {\r
+\r
+ private int index;\r
+\r
+ public GenericTypeSpec (int index) : base (0x13) {\r
+ this.index = index;\r
+ tabIx = MDTable.TypeSpec;\r
}\r
\r
+ internal sealed override void TypeSig(MemoryStream str) {\r
+ str.WriteByte(typeIndex);\r
+ MetaData.CompressNum ((uint) index, str);\r
+ }\r
+ }\r
\r
public class GenericTypeInst : Type {\r
\r
param.TypeSig (str);\r
}\r
}\r
-\r
- /// <summary>\r
- /// The IL Array type\r
- /// </summary>\r
- public abstract class Array : Type\r
- {\r
+
+ public class GenericMethodSig {
+
+ private Type[] gen_param;
+
+ public GenericMethodSig (Type[] gen_param)
+ {
+ this.gen_param = gen_param;
+ }
+
+ internal void TypeSig (MemoryStream str)
+ {
+ MetaData.CompressNum ((uint) gen_param.Length, str); // THIS IS NOT RIGHT, but works
+ MetaData.CompressNum ((uint) gen_param.Length, str);
+ foreach (Type param in gen_param)
+ param.TypeSig (str);
+ }
+
+ internal uint GetSigIx (MetaData md)
+ {
+ MemoryStream sig = new MemoryStream();
+ TypeSig (sig);
+ return md.AddToBlobHeap (sig.ToArray());
+ }
+ }
+
+ public class Sentinel : Type {
+
+ public Sentinel () : base (0x41) { }
+
+ internal sealed override void TypeSig(MemoryStream str) {
+ str.WriteByte(typeIndex);
+ }
+ }
+
+ /// <summary>\r
+ /// The IL Array type\r
+ /// </summary>\r
+ public abstract class Array : Type\r
+ {\r
\r
protected Type elemType;\r
protected MetaData metaData;\r
\r
internal Array(Type eType, byte TypeId) : base(TypeId) {\r
elemType = eType;\r
- tabIx = MDTable.TypeSpec;\r
- }\r
-\r
- internal Array(Class eClass, MetaData md, string nameSpace, string name,\r
- byte TypeId) : base(TypeId) {\r
- elemType = eClass;\r
- tabIx = MDTable.TypeSpec;\r
- metaData = md;\r
- cnameSpace = nameSpace;\r
- cname = name;\r
+ tabIx = MDTable.TypeSpec;\r
}\r
\r
- public Method AddMethod(string name, Type retType, Type[] pars) {\r
-\r
- if (metaData == null || cnameSpace == null || cname == null)\r
- throw new Exception ("Methods cannot be added to arrays not created with the Class.GetArray* methods.");\r
- Method meth = new MethodRef (GetTypeSpec (metaData), name, retType, pars, false, null);\r
- metaData.AddToTable(MDTable.MemberRef,meth);\r
-\r
- return meth;\r
- }\r
- \r
- }\r
+ }\r
\r
/**************************************************************************/ \r
\r
/// <param name="elementType">the type of the array elements</param>\r
public ZeroBasedArray(Type elementType) : base (elementType,0x1D) { }\r
\r
- public ZeroBasedArray(Class elementClass, MetaData md,\r
- string nameSpace, string name) : base (elementClass, md, nameSpace, name, 0x1D) { }\r
-\r
internal sealed override void TypeSig(MemoryStream str) {\r
str.WriteByte(typeIndex);\r
elemType.TypeSig(str); \r
}\r
}\r
\r
- internal BoundArray(Class elementClass, MetaData md, string nameSpace, string name,\r
- uint dimensions, int[] loBounds,\r
- int[] upBounds) : base (elementClass,md, nameSpace, name, 0x14) {\r
- numDims = dimensions;\r
- lowerBounds = loBounds;\r
- sizes = new int[loBounds.Length];\r
- for (int i=0; i < loBounds.Length; i++) {\r
- sizes[i] = upBounds[i] - loBounds[i] + 1;\r
- }\r
- }\r
-\r
/// <summary>\r
/// Create a new multi dimensional array type \r
/// eg. elemType[5,10,20] would be new BoundArray(elemType,3,[5,10,20])\r
{\r
ushort majorVer, minorVer, buildNo, revisionNo;\r
uint flags;\r
- HashAlgorithm hashAlgId = HashAlgorithm.None;\r
+ uint hashAlgId;
uint keyIx = 0, cultIx = 0;\r
\r
internal Assembly(string name, MetaData md) : base(name,md) {\r
/// <param name="hash">Hash Algorithm</param>\r
/// <param name="cult">Culture</param>\r
public void AddAssemblyInfo(int majVer, int minVer, int bldNo, int revNo, \r
- byte[] key, HashAlgorithm hash, string cult) {\r
+ byte[] key, uint hash, string cult) {\r
majorVer = (ushort)majVer;\r
minorVer = (ushort)minVer;\r
buildNo = (ushort)bldNo;\r
return 0;\r
}\r
\r
- } \r
+ } \r
/**************************************************************************/ \r
- /// <summary>\r
- /// A reference to an external assembly (.assembly extern)\r
- /// </summary>\r
- public class AssemblyRef : ResolutionScope\r
- {\r
+
+ public interface IExternRef {
+ ClassRef AddClass(string nsName, string name);
+ ClassRef AddValueClass(string nsName, string name);
+ }
+
+ /// <summary>\r
+ /// A reference to an external assembly (.assembly extern)\r
+ /// </summary>\r
+ public class AssemblyRef : ResolutionScope, IExternRef
+ {\r
private ushort major, minor, build, revision;\r
uint flags, keyIx, hashIx, cultIx;\r
bool hasVersion = false, isKeyToken = false;\r
\r
internal AssemblyRef(MetaData md, string name) : base(name,md) {\r
tabIx = MDTable.AssemblyRef;\r
- }\r
+ }\r
\r
/// <summary>\r
/// Add version information about this external assembly\r
}\r
return 0;\r
}\r
- \r
- }\r
+
+ }\r
/**************************************************************************/ \r
\r
/// <summary>\r
/// Method call conventions\r
/// </summary>\r
public enum CallConv { Default, Cdecl, Stdcall, Thiscall, \r
- Fastcall, Vararg, Instance = 0x20, InstanceExplicit = 0x60 }\r
+ Fastcall, Vararg, Instance = 0x20, Generic = 0x10, InstanceExplicit = 0x60 }\r
\r
/// <summary>\r
/// Type custom modifier\r
/// <summary>\r
/// Attributes for .pinvokeimpl method declarations\r
/// </summary>\r
- public enum PInvokeAttr { ansi = 2, unicode = 4, autochar = 6, \r
- platformapi = 0x100, cdecl = 0x200, stdcall = 0x300, thiscall = 0x400,\r
- fastcall = 0x500 }\r
+ public enum PInvokeAttr { nomangle = 1, ansi = 2, unicode = 4, autochar = 6,
+ lasterr = 0x0040, winapi = 0x0100, cdecl = 0x0200,
+ stdcall = 0x0300, thiscall = 0x0400, fastcall = 0x0500 }\r
\r
/// <summary>\r
/// Implementation attributes for a method\r
unbox = 0x79, stobj = 0x81, box = 0x8C, newarr, \r
ldelema = 0x8F, refanyval = 0xC2, mkrefany = 0xC6, \r
ldtoken = 0xD0, initobj = 0xFE15, sizeOf = 0xFE1C,\r
- ldelem = 0xA3, stelem = 0xA4 }\r
+ ldelem = 0xA3, stelem = 0xA4, unbox_any }\r
\r
/// <summary>\r
/// CIL branch instructions\r
/// </summary>\r
- public enum BranchOp {br = 0x2B, brfalse, brtrue, beq, bge, bgt, ble, blt,\r
- bne_un, bge_un, bgt_un, ble_un, blt_un, leave = 0xDE }\r
+ public enum BranchOp {
+ // short branches
+ br_s = 0x2B, brfalse_s, brtrue_s, beq_s, bge_s, bgt_s,
+ ble_s, blt_s, bne_un_s, bge_un_s, bgt_un_s, ble_un_s, blt_un_s,
+ // long branches
+ br = 0x38, brfalse, brtrue, beq, bge, bgt, ble, blt,\r
+ bne_un, bge_un, bgt_un, ble_un, blt_un,
+
+ leave = 0xDD, leave_s }\r
\r
/// <summary>\r
/// Index for all the tables in the meta data\r
internal enum MapType { eventMap, propertyMap, nestedClass }\r
\r
/**************************************************************************/ \r
- /// <summary>\r
- /// The assembly for mscorlib. \r
- /// </summary>\r
- public sealed class MSCorLib : AssemblyRef\r
- {\r
+ /// <summary>\r
+ /// The assembly for mscorlib. \r
+ /// </summary>\r
+ public sealed class MSCorLib : AssemblyRef\r
+ {\r
private static readonly int valueTypeIx = 18;\r
private readonly string systemName = "System";\r
private ClassRef[] systemClasses = new ClassRef[valueTypeIx+2];\r
return aClass;\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Signature for calli instruction\r
- /// </summary>\r
- public class CalliSig : Signature\r
- {\r
+ /// <summary>\r
+ /// Signature for calli instruction\r
+ /// </summary>\r
+ public class CalliSig : Signature\r
+ {\r
private static readonly byte Sentinel = 0x41;\r
CallConv callConv;\r
Type returnType;\r
Type[] parameters, optParams;\r
- uint numPars = 0, numOptPars = 0;\r
+ uint numPars = 0, numOptPars = 0;\r
\r
/// <summary>\r
/// Create a signature for a calli instruction\r
/// <param name="retType">return type</param>\r
/// <param name="pars">parameter types</param>\r
public CalliSig(CallConv cconv, Type retType, Type[] pars) {\r
- tabIx = MDTable.StandAloneSig;\r
+ tabIx = MDTable.StandAloneSig;\r
callConv = cconv;\r
returnType = retType;\r
parameters = pars;\r
- if (pars != null) numPars = (uint)pars.Length;\r
+ if (pars != null) numPars = (uint)pars.Length;\r
}\r
\r
/// <summary>\r
done = true;\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
/// <summary>\r
/// The IL instructions for a method\r
buffer[i] = tmp[i];\r
}\r
}\r
- //Console.WriteLine("Adding instruction at offset " + offset + " with size " + inst.size);\r
- inst.offset = offset;\r
+ //Console.WriteLine("Adding instruction at offset " + offset + " with size " + inst.size);\r
+ inst.offset = offset;\r
offset += inst.size;\r
buffer[tide++] = inst;\r
}\r
/// <param name="str">the string value</param>\r
public void ldstr(string str) {\r
AddToBuffer(new StringInstr(0x72,str));\r
- }\r
-\r
+ }
+
+ /// <summary>
+ /// Add the load string instruction
+ /// </summary>
+ public void ldstr (byte[] str) {
+ AddToBuffer (new StringInstr (0x72, str));
+ }
+
/// <summary>\r
/// Add the calli instruction\r
/// </summary>\r
offset = buffer[tide-1].offset + buffer[tide-1].size;\r
}\r
}\r
- codeSize = offset;\r
- // Console.WriteLine("codeSize before header added = " + codeSize);\r
+ codeSize = offset;\r
+ // Console.WriteLine("codeSize before header added = " + codeSize);\r
if ((offset < smallSize) && (maxStack <= 8) && (locSigIx == 0) && (exceptions == null)) {\r
// can use tiny header\r
//Console.WriteLine("Tiny Header");\r
numExceptClauses += (uint)tryBlock.NumHandlers();\r
if (tryBlock.isFat()) fatExceptionFormat = true;\r
}\r
+
+ uint data_size = ExHeaderSize + numExceptClauses *
+ (fatExceptionFormat ? FatExClauseSize : SmlExClauseSize);
+
+ if (data_size > 256)
+ fatExceptionFormat = true;
+
// Console.WriteLine("numexceptclauses = " + numExceptClauses);\r
if (fatExceptionFormat) {\r
// Console.WriteLine("Fat exception format");\r
if ((offset % 4) != 0) { paddingNeeded = 4 - (offset % 4); }\r
codeSize += FatSize;\r
}\r
- // Console.WriteLine("codeSize = " + codeSize + " headerFlags = " + \r
+ // Console.WriteLine("codeSize = " + codeSize + " headerFlags = " + \r
// Hex.Short(headerFlags));\r
}\r
\r
- internal void Write(FileImage output) {\r
+ internal void Write(FileImage output) {\r
// Console.WriteLine("Writing header flags = " + Hex.Short(headerFlags));\r
- if (tinyFormat) {\r
+ if (tinyFormat) {\r
// Console.WriteLine("Writing tiny code");\r
- output.Write((byte)headerFlags);\r
- } else {\r
+ output.Write((byte)headerFlags);\r
+ } else {\r
// Console.WriteLine("Writing fat code");\r
- output.Write(headerFlags);\r
- output.Write((ushort)maxStack);\r
- output.Write(offset);\r
- output.Write(localSigIx);\r
- }\r
+ output.Write(headerFlags);\r
+ output.Write((ushort)maxStack);\r
+ output.Write(offset);\r
+ output.Write(localSigIx);\r
+ }\r
// Console.WriteLine(Hex.Int(tide) + " CIL instructions");\r
// Console.WriteLine("starting instructions at " + output.Seek(0,SeekOrigin.Current));\r
- for (int i=0; i < tide; i++) {\r
- buffer[i].Write(output);\r
- }\r
+ for (int i=0; i < tide; i++) {\r
+ buffer[i].Write(output);\r
+ }\r
// Console.WriteLine("ending instructions at " + output.Seek(0,SeekOrigin.Current));\r
for (int i=0; i < paddingNeeded; i++) { output.Write((byte)0); }\r
if (exceptions != null) {\r
tryBlock.Write(output,fatExceptionFormat);\r
}\r
}\r
- }\r
+ }\r
\r
}\r
/**************************************************************************/ \r
- /// <summary>\r
- /// A label in the IL\r
- /// </summary>\r
- public class CILLabel\r
- {\r
+ /// <summary>\r
+ /// A label in the IL\r
+ /// </summary>\r
+ public class CILLabel\r
+ {\r
CILInstruction branch;\r
CILInstruction[] multipleBranches;\r
int tide = 0;\r
uint offset = 0;\r
\r
public CILLabel (uint offset) {\r
- this.offset = offset;\r
- }\r
- \r
+ this.offset = offset;\r
+ }\r
+ \r
\r
internal CILLabel() {\r
}
-
- public CILLabel (uint i) {}\r
\r
internal void AddBranch(CILInstruction instr) {\r
if (branch == null) {\r
}\r
\r
internal uint GetLabelOffset() {\r
- if (offset > 0)\r
- return offset;\r
if (labInstr == null) return 0;\r
- return labInstr.offset;\r
+ return labInstr.offset + offset;\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
public abstract class CodeBlock {\r
\r
\r
/**************************************************************************/ \r
/// <summary>\r
- /// The base descriptor for a class \r
- /// </summary>\r
- public abstract class Class : Type\r
- {\r
+ /// The base descriptor for a class \r
+ /// </summary>\r
+ public abstract class Class : Type\r
+ {\r
protected int row = 0;\r
protected string name, nameSpace;\r
protected uint nameIx, nameSpaceIx;\r
protected MetaData _metaData;\r
- internal Class(string nameSpaceName, string className, MetaData md)\r
+ internal Class(string nameSpaceName, string className, MetaData md)\r
: base(0x12) {\r
nameSpace = nameSpaceName;\r
name = className;\r
nameIx = nIx;\r
}\r
\r
- public BoundArray GetBoundArray (uint dimensions, int[] loBounds,\r
- int[] upBounds) {\r
- BoundArray bound_array = new BoundArray (this, _metaData, nameSpace,\r
- name, dimensions, loBounds, upBounds);\r
- return bound_array;\r
- }\r
-\r
- public ZeroBasedArray GetZeroBasedArray () {\r
- ZeroBasedArray array = new ZeroBasedArray (this, _metaData,\r
- nameSpace, name);\r
- return array;\r
- }\r
-\r
internal virtual uint TypeDefOrRefToken() { return 0; }\r
\r
internal virtual void MakeValueClass() {\r
typeIndex = 0x11;\r
}\r
- \r
+ \r
internal virtual string TypeName() {\r
return (nameSpace + "." + name);\r
}\r
internal override MetaDataElement GetTypeSpec(MetaData md) {\r
return this;\r
}\r
- }\r
+ }\r
/**************************************************************************/ \r
// This Class produces entries in the TypeDef table of the MetaData \r
// in the PE meta data.\r
// which is the parent for functions and variables declared a module level\r
\r
/// <summary>\r
- /// The descriptor for a class defined in the IL (.class) in the current assembly/module\r
- /// </summary>\r
- /// \r
- public class ClassDef : Class\r
- {\r
+ /// The descriptor for a class defined in the IL (.class) in the current assembly/module\r
+ /// </summary>\r
+ /// \r
+ public class ClassDef : Class\r
+ {\r
private static readonly uint HasSecurity = 0x00040000;\r
private static readonly byte ElementType_Class = 0x12;\r
\r
\r
internal ClassDef(TypeAttr attrSet, string nsName, string name, \r
MetaData md) : base(nsName, name, md) {\r
- metaData = md;\r
+ metaData = md;\r
superType = metaData.mscorlib.GetSpecialSystemClass(PrimitiveType.Object);\r
flags = (uint)attrSet;\r
tabIx = MDTable.TypeDef;\r
typeIndex = superType.GetTypeIndex();\r
}\r
\r
- internal void SpecialNoSuper() {\r
+ public void SpecialNoSuper() {\r
superType = null;\r
}\r
\r
metaData.AddToTable(MDTable.InterfaceImpl,new InterfaceImpl(this,iFace));\r
}\r
\r
- /// <summary>\r
- /// Add a generic type parameter.\r
- /// </summary>\r
- public void AddGenericParameter (short index) {\r
- metaData.AddToTable (MDTable.GenericParam, new GenericParameter (this, index));\r
- }\r
-\r
/// <summary>\r
/// Add a named generic type parameter\r
/// </summary>\r
- public void AddGenericParameter (short index, string name) {\r
- metaData.AddToTable (MDTable.GenericParam, new GenericParameter (this, index, name));\r
- }\r
-\r
- public void AddGenericParameter (short index, Type constraint) {\r
- GenericParameter gp = new GenericParameter (this, index);\r
- metaData.AddToTable (MDTable.GenericParam, gp);\r
- metaData.AddToTable (MDTable.GenericParamConstraint,\r
- new GenericParamConstraint (gp, constraint));\r
- }\r
-\r
- public void AddGenericParameter (short index, string name, Type constraint) {\r
- GenericParameter gp = new GenericParameter (this, index, name);\r
- metaData.AddToTable (MDTable.GenericParam, gp);\r
- metaData.AddToTable (MDTable.GenericParamConstraint,\r
- new GenericParamConstraint (gp, constraint));\r
+ public GenericParameter AddGenericParameter (short index, string name) {\r
+ GenericParameter gp = new GenericParameter (this, metaData, index, name);
+ metaData.AddToTable (MDTable.GenericParam, gp);\r
+ return gp;
}\r
\r
/// <summary>\r
fields.Add(field);\r
return field;\r
}\r
-\r
+
+ public void SetFieldOrder (ArrayList fields)
+ {
+ this.fields = fields;
+ }
+
/// <summary>\r
/// Add a method to this class\r
/// </summary>\r
md.AddToTable(MDTable.PropertyMap,new MapElem(this,\r
((Property)properties[0]).Row,MDTable.Property));\r
}\r
- DoCustomAttributes (md);\r
// Console.WriteLine("End of building tables");\r
done = true;\r
}\r
return 0;\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Layout information for a class (.class [sequential | explicit])\r
- /// </summary>\r
- internal class ClassLayout : MetaDataElement\r
- {\r
+ /// <summary>\r
+ /// Layout information for a class (.class [sequential | explicit])\r
+ /// </summary>\r
+ internal class ClassLayout : MetaDataElement\r
+ {\r
ClassDef parent;\r
ushort packSize = 0;\r
uint classSize = 0;\r
\r
- internal ClassLayout(int pack, int cSize, ClassDef par) {\r
+ internal ClassLayout(int pack, int cSize, ClassDef par) {\r
packSize = (ushort)pack;\r
classSize = (uint)cSize;\r
parent = par;\r
tabIx = MDTable.ClassLayout;\r
- }\r
+ }\r
\r
internal sealed override uint Size(MetaData md) {\r
return 6 + md.TableIndexSize(MDTable.TypeDef);\r
output.WriteIndex(MDTable.TypeDef,parent.Row);\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for a class/interface declared in another module of THIS \r
- /// assembly, or in another assembly.\r
- /// </summary>\r
- public class ClassRef : Class\r
- {\r
+ /// <summary>\r
+ /// Descriptor for a class/interface declared in another module of THIS \r
+ /// assembly, or in another assembly.\r
+ /// </summary>\r
+ public class ClassRef : Class\r
+ {\r
protected ResolutionScope parent;\r
ExternClass externClass;\r
protected MetaData metaData;\r
\r
- internal ClassRef(string nsName, string name, MetaData md) : base(nsName, name, md) {\r
+ internal ClassRef(string nsName, string name, MetaData md) : base(nsName, name, md) {\r
metaData = md;\r
tabIx = MDTable.TypeRef;\r
}\r
return 0;\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
\r
public class ExternClassRef : ClassRef {\r
protected uint blobIndex;\r
protected bool addedToBlobHeap = false;\r
\r
- internal Constant() { }\r
+ internal Constant() { }\r
\r
internal virtual uint GetBlobIndex(MetaData md) { return 0; }\r
\r
\r
internal virtual void Write(BinaryWriter bw) { }\r
\r
- }\r
+ }\r
/// <summary>\r
/// Descriptor for a constant value\r
/// </summary>\r
\r
public IntConst(sbyte val) {\r
this.val = val;\r
- size = 8;\r
+ size = 1;\r
type = PrimitiveType.Int8;\r
}\r
\r
public IntConst(short val) {\r
this.val = val;\r
- size = 16;\r
+ size = 2;\r
type = PrimitiveType.Int16;\r
}\r
\r
public IntConst(int val) {\r
this.val = val;\r
- size = 32;\r
+ size = 4;\r
type = PrimitiveType.Int32;\r
}\r
\r
public IntConst(long val) {\r
this.val = val;\r
- size = 64;\r
+ size = 8;\r
type = PrimitiveType.Int64;\r
}\r
\r
\r
public UIntConst(sbyte val) {\r
this.val = val;\r
- size = 8;\r
+ size = 1;\r
type = PrimitiveType.UInt8;\r
}\r
public UIntConst(short val) {\r
this.val = val;\r
- size = 16;\r
+ size = 2;\r
type = PrimitiveType.UInt16;\r
}\r
public UIntConst(int val) {\r
this.val = val;\r
- size = 32;\r
+ size = 4;\r
type = PrimitiveType.UInt32;\r
}\r
public UIntConst(long val) {\r
this.val = val;\r
- size = 64;\r
+ size = 8;\r
type = PrimitiveType.UInt64;\r
}\r
\r
}\r
\r
internal sealed override uint GetBlobIndex(MetaData md) {\r
- if (!addedToBlobHeap) {\r
- blobIndex = md.AddToBlobHeap(val);\r
+ if (!addedToBlobHeap) {
+ byte [] b = Encoding.Unicode.GetBytes (val);
+ blobIndex = md.AddToBlobHeap(b);\r
addedToBlobHeap = true;\r
}\r
return blobIndex;\r
\r
\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Summary description for ConstantElem.\r
- /// </summary>\r
- internal class ConstantElem : MetaDataElement\r
- {\r
+ /// <summary>\r
+ /// Summary description for ConstantElem.\r
+ /// </summary>\r
+ internal class ConstantElem : MetaDataElement\r
+ {\r
MetaDataElement parent;\r
Constant cValue;\r
uint valIx = 0;\r
\r
- internal ConstantElem(MetaDataElement parent, Constant val) {\r
+ internal ConstantElem(MetaDataElement parent, Constant val) {\r
this.parent = parent;\r
cValue = val;\r
- tabIx = MDTable.Constant;\r
- }\r
+ tabIx = MDTable.Constant;\r
+ }\r
\r
internal sealed override void BuildTables(MetaData md) {\r
if (done) return;\r
output.BlobIndex(valIx);\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for a Custom Attribute (.custom) \r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for a Custom Attribute (.custom) \r
+ /// </summary>\r
\r
- public class CustomAttribute : MetaDataElement\r
- {\r
+ public class CustomAttribute : MetaDataElement\r
+ {\r
private static readonly ushort prolog = 0x0001;\r
MetaDataElement parent;\r
Method type;\r
ushort numNamed = 0;\r
ArrayList names, vals;\r
\r
- internal CustomAttribute(MetaDataElement paren, Method constrType, \r
+ internal CustomAttribute(MetaDataElement paren, Method constrType, \r
Constant val) {\r
parent = paren;\r
type = constrType;\r
cVal = val;\r
tabIx = MDTable.CustomAttribute;\r
throw(new NotYetImplementedException("Custom Attributes "));\r
- }\r
+ }\r
\r
internal CustomAttribute(MetaDataElement paren, Method constrType,\r
byte[] val) {\r
\r
internal sealed override void BuildTables(MetaData md) {\r
BinaryWriter bw = new BinaryWriter(new MemoryStream());\r
- bw.Write((ushort)1);\r
+ bw.Write(byteVal);\r
md.AddToTable(MDTable.CustomAttribute, this);\r
MemoryStream str = (MemoryStream)bw.BaseStream;\r
valIx = md.AddToBlobHeap(str.ToArray());\r
output.BlobIndex(valIx);\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for a custom modifier of a type (modopt or modreq)\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for a custom modifier of a type (modopt or modreq)\r
+ /// </summary>\r
\r
- public class CustomModifiedType : Type\r
- {\r
+ public class CustomModifiedType : Type\r
+ {\r
Type type;\r
Class cmodType;\r
\r
/// <param name="type">the type to be modified</param>\r
/// <param name="cmod">the modifier</param>\r
/// <param name="cmodType">the type reference to be associated with the type</param>\r
- public CustomModifiedType(Type type, CustomModifier cmod, Class cmodType)\r
+ public CustomModifiedType(Type type, CustomModifier cmod, Class cmodType)\r
: base((byte)cmod) {\r
this.type = type;\r
this.cmodType = cmodType;\r
- }\r
+ }\r
\r
internal sealed override void TypeSig(MemoryStream str) {\r
str.WriteByte(typeIndex);\r
/// <summary>\r
/// Descriptor for security permissions for a class or a method NOT YET IMPLEMENTED\r
/// </summary>\r
- \r
- public class DeclSecurity : MetaDataElement\r
- {\r
+ \r
+ public class DeclSecurity : MetaDataElement\r
+ {\r
ushort action;\r
MetaDataElement parent;\r
uint permissionIx;\r
\r
- internal DeclSecurity(MetaDataElement paren, ushort act) {\r
+ internal DeclSecurity(MetaDataElement paren, ushort act) {\r
parent = paren;\r
action = act;\r
tabIx = MDTable.DeclSecurity;\r
throw(new NotYetImplementedException("Security "));\r
- }\r
+ }\r
\r
internal sealed override uint Size(MetaData md) {\r
return 2 + md.CodedIndexSize(CIx.HasDeclSecurity) + md.BlobIndexSize();\r
output.BlobIndex(permissionIx);\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for an event\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for an event\r
+ /// </summary>\r
public class Event : Feature\r
- {\r
+ {\r
Type eventType;\r
\r
internal Event(string name, Type eType, ClassDef parent) \r
: base(name, parent) {\r
eventType = eType;\r
- tabIx = MDTable.Event;\r
+ tabIx = MDTable.Event;\r
}\r
\r
/// <summary>\r
return 0;\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for a class defined in another module of THIS assembly \r
- /// and exported (.class extern)\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for a class defined in another module of THIS assembly \r
+ /// and exported (.class extern)\r
+ /// </summary>\r
\r
internal class ExternClass : Class\r
- {\r
- MetaDataElement parent;\r
+ {\r
+ MetaDataElement parent;\r
uint flags;\r
\r
internal ExternClass(TypeAttr attr, uint nsIx, uint nIx, \r
MetaDataElement paren) : base(nsIx,nIx) {\r
flags = (uint)attr;\r
- parent = paren;\r
- tabIx = MDTable.ExportedType;\r
+ parent = paren;\r
+ tabIx = MDTable.ExportedType;\r
}\r
\r
internal sealed override uint Size(MetaData md) {\r
return 0;\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Base class for Event and Property descriptors\r
- /// </summary>\r
+ /// <summary>\r
+ /// Base class for Event and Property descriptors\r
+ /// </summary>\r
\r
public class Feature : MetaDataElement\r
- {\r
+ {\r
internal enum MethodType : ushort { Setter = 0x01, Getter, Other = 0x04, AddOn = 0x08, \r
RemoveOn = 0x10, Fire = 0x20 }\r
\r
flags |= rtSpecialName;\r
}\r
\r
- }\r
+ }\r
/*****************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for a field of a class\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for a field of a class\r
+ /// </summary>\r
\r
public abstract class Field : Member\r
- {\r
+ {\r
protected static readonly byte FieldSig = 0x6;\r
\r
protected Type type;\r
\r
- internal Field(string pfName, Type pfType) : base(pfName)\r
- {\r
+ internal Field(string pfName, Type pfType) : base(pfName)\r
+ {\r
type = pfType;\r
- }\r
+ }\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for a field defined in a class of THIS assembly/module\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for a field defined in a class of THIS assembly/module\r
+ /// </summary>\r
public class FieldDef : Field\r
- {\r
+ {\r
//private static readonly uint PInvokeImpl = 0x2000;\r
private static readonly ushort HasFieldMarshal = 0x1000;\r
private static readonly ushort HasFieldRVA = 0x100;\r
+ private static readonly ushort HasDefault = 0x8000;
\r
FieldRVA rva;\r
ConstantElem constVal;\r
/// <param name="val">the value for the field</param>\r
public void AddValue(Constant val) {\r
constVal = new ConstantElem(this,val);\r
+ flags |= HasDefault;
}\r
\r
/// <summary>\r
return 0;\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for layout information for a field\r
- /// </summary>\r
- \r
- public class FieldLayout : MetaDataElement\r
- {\r
+ /// <summary>\r
+ /// Descriptor for layout information for a field\r
+ /// </summary>\r
+ \r
+ public class FieldLayout : MetaDataElement\r
+ {\r
Field field;\r
uint offset;\r
\r
- internal FieldLayout(Field field, uint offset) {\r
+ internal FieldLayout(Field field, uint offset) {\r
this.field = field;\r
this.offset = offset;\r
- tabIx = MDTable.FieldLayout;\r
+ tabIx = MDTable.FieldLayout;\r
}\r
\r
internal sealed override uint Size(MetaData md) {\r
output.WriteIndex(MDTable.Field,field.Row);\r
}\r
\r
- }\r
+ }\r
/*****************************************************************************/ \r
- /// <summary>\r
- /// Marshalling information for a field or param\r
- /// </summary>\r
+ /// <summary>\r
+ /// Marshalling information for a field or param\r
+ /// </summary>\r
public class FieldMarshal : MetaDataElement\r
- {\r
+ {\r
MetaDataElement field;\r
NativeType nt;\r
uint ntIx;\r
\r
- internal FieldMarshal(MetaDataElement field, NativeType nType) {\r
+ internal FieldMarshal(MetaDataElement field, NativeType nType) {\r
this.field = field;\r
this.nt = nType;\r
- tabIx = MDTable.FieldMarshal;\r
- }\r
+ tabIx = MDTable.FieldMarshal;\r
+ }\r
\r
internal sealed override void BuildTables(MetaData md) {\r
if (done) return;\r
output.BlobIndex(ntIx);\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for a field of a class defined in another assembly/module\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for a field of a class defined in another assembly/module\r
+ /// </summary>\r
public class FieldRef : Field\r
- {\r
+ {\r
MetaDataElement parent;\r
\r
- internal FieldRef(MetaDataElement paren, string name, Type fType) : base(name, fType) { \r
+ internal FieldRef(MetaDataElement paren, string name, Type fType) : base(name, fType) { \r
parent = paren;\r
}\r
\r
\r
internal sealed override uint GetCodedIx(CIx code) { return 6; }\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for the address of a field's value in the PE file\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for the address of a field's value in the PE file\r
+ /// </summary>\r
public class FieldRVA : MetaDataElement\r
- {\r
+ {\r
Field field;\r
DataConstant data;\r
\r
- internal FieldRVA(Field field, DataConstant data) {\r
+ internal FieldRVA(Field field, DataConstant data) {\r
this.field = field;\r
this.data = data;\r
tabIx = MDTable.FieldRVA;\r
- }\r
+ }\r
\r
internal sealed override void BuildTables(MetaData md) {\r
if (done) return;\r
output.WriteIndex(MDTable.Field,field.Row);\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Image for a PEFile\r
- /// File Structure\r
+ /// <summary>\r
+ /// Image for a PEFile\r
+ /// File Structure\r
/// DOS Header (128 bytes) \r
/// PE Signature ("PE\0\0") \r
/// PEFileHeader (20 bytes)\r
/// Rows (4 bytes * numTables)\r
/// Tables\r
/// </summary>\r
- internal class FileImage : BinaryWriter\r
- {\r
+ internal class FileImage : BinaryWriter\r
+ {\r
internal readonly static uint[] iByteMask = {0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000};\r
internal readonly static ulong[] lByteMask = {0x00000000000000FF, 0x000000000000FF00,\r
0x0000000000FF0000, 0x00000000FF000000,\r
private static readonly uint CLIHeaderSize = 72;\r
private uint runtimeFlags = 0x01; // COMIMAGE_FLAGS_ILONLY\r
// 32BITREQUIRED 0x02, STRONGNAMESIGNED 0x08, TRACKDEBUGDATA 0x10000\r
- private static readonly uint relocFlags = 0x42000040;\r
- private static readonly ushort exeCharacteristics = 0x010E;\r
- private static readonly ushort dllCharacteristics = 0x210E;\r
+ private static readonly uint relocFlags = 0x42000040;\r
+ private static readonly ushort exeCharacteristics = 0x010E;\r
+ private static readonly ushort dllCharacteristics = 0x210E;\r
// section names are all 8 bytes\r
private static readonly string textName = ".text\0\0\0";\r
private static readonly string sdataName = ".sdata\0\0";\r
private static readonly string dllHintNameTable = "\0\0_CorDllMain\0";\r
private static readonly string runtimeEngineName = "mscoree.dll\0\0";\r
\r
- private Section text, sdata, rsrc;\r
- ArrayList data;\r
+ private Section text, sdata, rsrc;\r
+ ArrayList data;\r
BinaryWriter reloc = new BinaryWriter(new MemoryStream());\r
uint dateStamp = 0;\r
DateTime origin = new DateTime(1970,1,1);\r
uint importTableOffset, importLookupTableOffset, totalImportTableSize;\r
MetaData metaData;\r
char[] runtimeEngine = runtimeEngineName.ToCharArray(), hintNameTable;\r
- bool doDLL, largeStrings, largeGUID, largeUS, largeBlob;\r
- ushort characteristics;\r
+ bool doDLL, largeStrings, largeGUID, largeUS, largeBlob;\r
+ ushort characteristics;\r
\r
internal FileImage(bool makeDLL, string fileName) : base(new FileStream(fileName,FileMode.Create)) {\r
InitFileImage(makeDLL);\r
\r
private void InitFileImage(bool makeDLL) {\r
doDLL = makeDLL;\r
- if (doDLL) {\r
- hintNameTable = dllHintNameTable.ToCharArray();\r
- characteristics = dllCharacteristics;\r
- } else {\r
- hintNameTable = exeHintNameTable.ToCharArray();\r
- characteristics = exeCharacteristics;\r
- }\r
+ if (doDLL) {\r
+ hintNameTable = dllHintNameTable.ToCharArray();\r
+ characteristics = dllCharacteristics;\r
+ } else {\r
+ hintNameTable = exeHintNameTable.ToCharArray();\r
+ characteristics = exeCharacteristics;\r
+ }\r
text = new Section(textName,0x60000020); // IMAGE_SCN_CNT CODE, EXECUTE, READ\r
-// rsrc = new Section(rsrcName,0x40000040); // IMAGE_SCN_CNT INITIALIZED_DATA, READ\r
+// rsrc = new Section(rsrcName,0x40000040); // IMAGE_SCN_CNT INITIALIZED_DATA, READ\r
metaData = new MetaData(this);\r
}\r
\r
- internal MetaData GetMetaData() {\r
- return metaData;\r
- }\r
+ internal MetaData GetMetaData() {\r
+ return metaData;\r
+ }\r
\r
private uint GetNextSectStart(uint rva, uint tide) {\r
if (tide < SectionAlignment) return rva + SectionAlignment;\r
text.AddReloc(entryPointOffset+2);\r
text.IncTide(entryPointOffset + 6);\r
//if (text.Tide() < fileAlign) fileAlign = minFileAlign;\r
- text.SetSize(NumToAlign(text.Tide(),fileAlign));\r
+ text.SetSize(NumToAlign(text.Tide(),fileAlign));\r
// Console.WriteLine("text size = " + text.Size() + " text tide = " + text.Tide() + " text padding = " + text.Padding());\r
- // Console.WriteLine("metaDataOffset = " + Hex.Int(metaDataOffset));\r
- // Console.WriteLine("importTableOffset = " + Hex.Int(importTableOffset));\r
- // Console.WriteLine("importLookupTableOffset = " + Hex.Int(importLookupTableOffset));\r
- // Console.WriteLine("hintNameTableOffset = " + Hex.Int(hintNameTableOffset));\r
- // Console.WriteLine("runtimeEngineOffset = " + Hex.Int(runtimeEngineOffset));\r
- // Console.WriteLine("entryPointOffset = " + Hex.Int(entryPointOffset));\r
- // Console.WriteLine("entryPointPadding = " + Hex.Int(entryPointPadding));\r
+ // Console.WriteLine("metaDataOffset = " + Hex.Int(metaDataOffset));\r
+ // Console.WriteLine("importTableOffset = " + Hex.Int(importTableOffset));\r
+ // Console.WriteLine("importLookupTableOffset = " + Hex.Int(importLookupTableOffset));\r
+ // Console.WriteLine("hintNameTableOffset = " + Hex.Int(hintNameTableOffset));\r
+ // Console.WriteLine("runtimeEngineOffset = " + Hex.Int(runtimeEngineOffset));\r
+ // Console.WriteLine("entryPointOffset = " + Hex.Int(entryPointOffset));\r
+ // Console.WriteLine("entryPointPadding = " + Hex.Int(entryPointPadding));\r
\r
}\r
\r
internal void BuildRelocSection() {\r
- text.DoRelocs(reloc);\r
- if (sdata != null) sdata.DoRelocs(reloc);\r
- if (rsrc != null) rsrc.DoRelocs(reloc);\r
+ text.DoRelocs(reloc);\r
+ if (sdata != null) sdata.DoRelocs(reloc);\r
+ if (rsrc != null) rsrc.DoRelocs(reloc);\r
relocTide = (uint)reloc.Seek(0,SeekOrigin.Current);\r
relocPadding = NumToAlign(relocTide,fileAlign);\r
relocSize = relocTide + relocPadding;\r
- imageSize = relocRVA + SectionAlignment;\r
+ imageSize = relocRVA + SectionAlignment;\r
initDataSize += relocSize;\r
}\r
\r
private void CalcOffsets() {\r
+if (sdata != null)
+ numSections++;
+if (rsrc != null)
+ numSections++;
headerSize = fileHeaderSize + (numSections * sectionHeaderSize);\r
headerPadding = NumToAlign(headerSize,fileAlign);\r
headerSize += headerPadding;\r
text.SetRVA(rva);\r
offset += text.Size();\r
rva = GetNextSectStart(rva,text.Tide());\r
- // Console.WriteLine("headerSize = " + headerSize);\r
- // Console.WriteLine("headerPadding = " + headerPadding);\r
- // Console.WriteLine("textOffset = " + Hex.Int(text.Offset()));\r
- if (sdata != null) { \r
- numSections++;\r
- sdata.SetSize(NumToAlign(sdata.Tide(),fileAlign));\r
- sdata.SetOffset(offset);\r
+ // Console.WriteLine("headerSize = " + headerSize);\r
+ // Console.WriteLine("headerPadding = " + headerPadding);\r
+ // Console.WriteLine("textOffset = " + Hex.Int(text.Offset()));\r
+ if (sdata != null) { \r
+ sdata.SetSize(NumToAlign(sdata.Tide(),fileAlign));\r
+ sdata.SetOffset(offset);\r
sdata.SetRVA(rva);\r
- offset += sdata.Size();\r
+ offset += sdata.Size();
rva = GetNextSectStart(rva,sdata.Tide());\r
- initDataSize += sdata.Size();\r
+ initDataSize += sdata.Size();\r
}\r
if (rsrc != null) { \r
- numSections++;\r
- rsrc.SetSize(NumToAlign(rsrc.Tide(),fileAlign));\r
- rsrc.SetOffset(offset);\r
+ rsrc.SetSize(NumToAlign(rsrc.Tide(),fileAlign));\r
+ rsrc.SetOffset(offset);\r
rsrc.SetRVA(rva);\r
offset += rsrc.Size();\r
rva = GetNextSectStart(rva,rsrc.Tide());\r
- initDataSize += rsrc.Size();\r
+ initDataSize += rsrc.Size();\r
}\r
relocOffset = offset;\r
relocRVA = rva;\r
\r
private void WriteHeader() {\r
Write(DOSHeader);\r
- // Console.WriteLine("Writing PEHeader at offset " + Seek(0,SeekOrigin.Current));\r
- WritePEHeader();\r
- // Console.WriteLine("Writing text section header at offset " + Hex.Long(Seek(0,SeekOrigin.Current)));\r
- text.WriteHeader(this,relocRVA);\r
+ // Console.WriteLine("Writing PEHeader at offset " + Seek(0,SeekOrigin.Current));\r
+ WritePEHeader();\r
+ // Console.WriteLine("Writing text section header at offset " + Hex.Long(Seek(0,SeekOrigin.Current)));\r
+ text.WriteHeader(this,relocRVA);\r
if (sdata != null) sdata.WriteHeader(this,relocRVA);\r
if (rsrc != null) rsrc.WriteHeader(this,relocRVA);\r
- // Console.WriteLine("Writing reloc section header at offset " + Seek(0,SeekOrigin.Current));\r
- WriteRelocSectionHeader();\r
- // Console.WriteLine("Writing padding at offset " + Seek(0,SeekOrigin.Current));\r
- WriteZeros(headerPadding);\r
+ // Console.WriteLine("Writing reloc section header at offset " + Seek(0,SeekOrigin.Current));\r
+ WriteRelocSectionHeader();\r
+ // Console.WriteLine("Writing padding at offset " + Seek(0,SeekOrigin.Current));\r
+ WriteZeros(headerPadding);\r
}\r
\r
private void WriteSections() {\r
- // Console.WriteLine("Writing text section at offset " + Seek(0,SeekOrigin.Current));\r
+ // Console.WriteLine("Writing text section at offset " + Seek(0,SeekOrigin.Current));\r
WriteTextSection();\r
if (sdata != null) WriteSDataSection();\r
if (rsrc != null) WriteRsrcSection();\r
Write(0);\r
}\r
\r
- private void WriteImportTables() {\r
- // Import Table\r
+ private void WriteImportTables() {\r
+ // Import Table\r
WriteZeros(importTablePadding);\r
// Console.WriteLine("Writing import tables at offset " + Hex.Long(Seek(0,SeekOrigin.Current)));\r
- Write(importLookupTableOffset + text.RVA());\r
- WriteZeros(8); \r
- Write(runtimeEngineOffset + text.RVA());\r
- Write(text.RVA()); // IAT is at the beginning of the text section\r
- WriteZeros(20);\r
- // Import Lookup Table\r
- WriteIAT(); // lookup table and IAT are the same\r
- // Hint/Name Table\r
+ Write(importLookupTableOffset + text.RVA());\r
+ WriteZeros(8); \r
+ Write(runtimeEngineOffset + text.RVA());\r
+ Write(text.RVA()); // IAT is at the beginning of the text section\r
+ WriteZeros(20);\r
+ // Import Lookup Table\r
+ WriteIAT(); // lookup table and IAT are the same\r
+ // Hint/Name Table\r
// Console.WriteLine("Writing hintname table at " + Hex.Long(Seek(0,SeekOrigin.Current)));\r
- Write(hintNameTable);\r
+ Write(hintNameTable);\r
Write(runtimeEngineName.ToCharArray());\r
- }\r
+ }\r
\r
private void WriteTextSection() {\r
WriteIAT();\r
largeBlob = metaData.LargeBlobIndex();\r
metaData.WriteMetaData(this);\r
WriteImportTables();\r
- WriteZeros(entryPointPadding);\r
- Write((ushort)0x25FF);\r
- Write(ImageBase + text.RVA());\r
- WriteZeros(text.Padding());\r
+ WriteZeros(entryPointPadding);\r
+ Write((ushort)0x25FF);\r
+ Write(ImageBase + text.RVA());\r
+ WriteZeros(text.Padding());\r
}\r
\r
private void WriteCLIHeader() {\r
}\r
\r
private void WriteSDataSection() {\r
+ long size = sdata.Size ();
+ long start = BaseStream.Position;
for (int i=0; i < data.Count; i++) {\r
((DataConstant)data[i]).Write(this);\r
- }\r
+ }
+ while (BaseStream.Position < (start + size))
+ Write ((byte) 0);
}\r
\r
- private void WriteRsrcSection() {\r
- }\r
+ private void WriteRsrcSection() {\r
+ }\r
\r
private void WriteRelocSection() {\r
// Console.WriteLine("Writing reloc section at " + Seek(0,SeekOrigin.Current) + " = " + relocOffset);\r
}\r
\r
internal void AddInitData(DataConstant cVal) {\r
- if (sdata == null) { \r
- sdata = new Section(sdataName,0xC0000040); // IMAGE_SCN_CNT INITIALIZED_DATA, READ, WRITE\r
- data = new ArrayList(); \r
- }\r
+ if (sdata == null) { \r
+ sdata = new Section(sdataName,0xC0000040); // IMAGE_SCN_CNT INITIALIZED_DATA, READ, WRITE\r
+ data = new ArrayList(); \r
+ }\r
data.Add(cVal);\r
cVal.DataOffset = sdata.Tide();\r
sdata.IncTide(cVal.GetSize());\r
Write(0); // Check other sections here!!\r
Write(text.RVA() + entryPointOffset);\r
Write(text.RVA());\r
- uint dataBase = 0;\r
- if (sdata != null) dataBase = sdata.RVA();\r
- else if (rsrc != null) dataBase = rsrc.RVA();\r
+ uint dataBase = 0;\r
+ if (sdata != null) dataBase = sdata.RVA();\r
+ else if (rsrc != null) dataBase = rsrc.RVA();\r
else dataBase = relocRVA;\r
- Write(dataBase);\r
+ Write(dataBase);\r
Write(ImageBase);\r
Write(SectionAlignment);\r
Write(fileAlign);\r
Write(b3);\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for a file referenced in THIS assembly/module (.file)\r
- /// </summary>\r
- public class FileRef : MetaDataElement\r
- {\r
- private static readonly uint HasMetaData = 0x1;\r
+ /// <summary>\r
+ /// Descriptor for a file referenced in THIS assembly/module (.file)\r
+ /// </summary>\r
+ public class FileRef : MetaDataElement\r
+ {\r
+ private static readonly uint NoMetaData = 0x1;\r
uint nameIx = 0, hashIx = 0;\r
uint flags = 0;\r
\r
internal FileRef(string name, byte[] hashBytes, bool metaData,\r
bool entryPoint, MetaData md) {\r
- if (metaData) flags = HasMetaData;\r
+ if (!metaData) flags = NoMetaData;\r
if (entryPoint) md.SetEntryPoint(this);\r
nameIx = md.AddToStringsHeap(name);\r
hashIx = md.AddToBlobHeap(hashBytes);\r
tabIx = MDTable.File;\r
- }\r
+ }\r
\r
internal FileRef(uint nameIx, byte[] hashBytes, bool metaData,\r
bool entryPoint, MetaData md) {\r
- if (metaData) flags = HasMetaData;\r
+ if (!metaData) flags = NoMetaData;\r
if (entryPoint) md.SetEntryPoint(this);\r
this.nameIx = nameIx;\r
hashIx = md.AddToBlobHeap(hashBytes);\r
return 0;\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for pinvoke information for a method NOT YET IMPLEMENTED\r
- /// </summary>\r
- public class ImplMap : MetaDataElement\r
- {\r
+ /// <summary>\r
+ /// Descriptor for pinvoke information for a method NOT YET IMPLEMENTED\r
+ /// </summary>\r
+ public class ImplMap : MetaDataElement\r
+ {\r
private static readonly ushort NoMangle = 0x01;\r
ushort flags;\r
Method meth;\r
uint iNameIx;\r
ModuleRef importScope;\r
\r
- internal ImplMap(ushort flag, Method implMeth, string iName, ModuleRef mScope) {\r
+ internal ImplMap(ushort flag, Method implMeth, string iName, ModuleRef mScope) {\r
flags = flag;\r
meth = implMeth;\r
importName = iName;\r
tabIx = MDTable.ImplMap;\r
if (iName == null) flags |= NoMangle;\r
//throw(new NotYetImplementedException("PInvoke "));\r
- }\r
+ }\r
\r
internal sealed override void BuildTables(MetaData md) {\r
if (done) return;\r
output.WriteIndex(MDTable.ModuleRef,importScope.Row);\r
}\r
\r
- }\r
+ }\r
\r
/**************************************************************************/ \r
/// <summary>\r
protected static readonly sbyte maxByteVal = 127;\r
protected static readonly sbyte minByteVal = -128;\r
protected static readonly byte leadByte = 0xFE;\r
- protected static readonly uint USHeapIndex = 0x70000000;\r
+ protected static readonly uint USHeapIndex = 0x70000000;\r
protected static readonly int longInstrStart = (int)Op.arglist;\r
public bool twoByteInstr = false;\r
public uint size = 0;\r
return false;\r
}\r
\r
- internal virtual void Write(FileImage output) { }\r
+ internal virtual void Write(FileImage output) { }\r
\r
}\r
\r
}\r
}\r
\r
- internal override void Write(FileImage output) {\r
+ internal override void Write(FileImage output) {\r
//Console.WriteLine("Writing instruction " + instr + " with size " + size);\r
if (twoByteInstr) output.Write(leadByte);\r
output.Write((byte)instr);\r
- }\r
+ }\r
\r
}\r
\r
else size += 4;\r
}\r
\r
- internal sealed override void Write(FileImage output) {\r
- base.Write(output);\r
+ internal sealed override void Write(FileImage output) {\r
+ base.Write(output);\r
if (byteNum) \r
output.Write((sbyte)val);\r
else \r
- output.Write(val); \r
- }\r
+ output.Write(val); \r
+ }\r
\r
}\r
\r
int val;\r
bool byteNum;\r
\r
- internal UIntInstr(int inst, int num, bool byteSize) : base(inst) {\r
- val = num;\r
+ internal UIntInstr(int inst, int num, bool byteSize) : base(inst) {\r
+ val = num;\r
byteNum = byteSize;\r
if (byteNum) size++;\r
else size += 2;\r
- }\r
+ }\r
\r
- internal sealed override void Write(FileImage output) {\r
- base.Write(output);\r
+ internal sealed override void Write(FileImage output) {\r
+ base.Write(output);\r
if (byteNum)\r
- output.Write((byte)val);\r
+ output.Write((byte)val);\r
else\r
- output.Write((ushort)val); \r
- }\r
- \r
+ output.Write((ushort)val); \r
+ }\r
+ \r
}\r
\r
- internal class LongInstr : Instr {\r
- long val;\r
+ internal class LongInstr : Instr {\r
+ long val;\r
\r
- internal LongInstr(int inst, long l) : base(inst) {\r
- val = l;\r
- size += 8;\r
- }\r
+ internal LongInstr(int inst, long l) : base(inst) {\r
+ val = l;\r
+ size += 8;\r
+ }\r
\r
- internal sealed override void Write(FileImage output) {\r
- base.Write(output);\r
- output.Write(val);\r
- }\r
+ internal sealed override void Write(FileImage output) {\r
+ base.Write(output);\r
+ output.Write(val);\r
+ }\r
\r
- }\r
+ }\r
\r
internal class FloatInstr : Instr {\r
float fVal;\r
size += 4;\r
}\r
\r
- internal sealed override void Write(FileImage output) {\r
- base.Write(output);\r
- output.Write(fVal);\r
- }\r
+ internal sealed override void Write(FileImage output) {\r
+ base.Write(output);\r
+ output.Write(fVal);\r
+ }\r
\r
- }\r
+ }\r
\r
internal class DoubleInstr : Instr {\r
double val;\r
size += 8;\r
}\r
\r
- internal sealed override void Write(FileImage output) {\r
- base.Write(output);\r
- output.Write(val);\r
- }\r
+ internal sealed override void Write(FileImage output) {\r
+ base.Write(output);\r
+ output.Write(val);\r
+ }\r
\r
- }\r
+ }\r
\r
internal class StringInstr : Instr {\r
- string val;\r
+ string val;
+ byte[] bval;
uint strIndex;\r
\r
internal StringInstr(int inst, string str) : base(inst) {\r
val = str; \r
size += 4;\r
- }\r
-\r
- internal sealed override bool Check(MetaData md) {\r
- strIndex = md.AddToUSHeap(val);\r
+ }
+
+ internal StringInstr (int inst, byte[] str) : base (inst) {
+ bval = str;
+ size += 4;
+ }
+
+ internal sealed override bool Check(MetaData md) {
+ if (val != null)
+ strIndex = md.AddToUSHeap(val);
+ else
+ strIndex = md.AddToUSHeap (bval);
return false;\r
}\r
\r
- internal sealed override void Write(FileImage output) {\r
- base.Write(output);\r
- output.Write(USHeapIndex | strIndex);\r
- }\r
+ internal sealed override void Write(FileImage output) {\r
+ base.Write(output);\r
+ output.Write(USHeapIndex | strIndex);\r
+ }\r
\r
- }\r
+ }\r
\r
internal class LabelInstr : CILInstruction {\r
CILLabel label;\r
size += 4;\r
}\r
\r
- internal sealed override void Write(FileImage output) {\r
- base.Write(output);\r
- output.Write(field.Token());\r
- }\r
+ internal sealed override void Write(FileImage output) {\r
+ base.Write(output);\r
+ output.Write(field.Token());\r
+ }\r
\r
- }\r
+ }\r
\r
internal class MethInstr : Instr {\r
Method meth;\r
size += 4;\r
}\r
\r
- internal sealed override void Write(FileImage output) {\r
- base.Write(output);\r
- output.Write(meth.Token());\r
- }\r
+ internal sealed override void Write(FileImage output) {\r
+ base.Write(output);\r
+ output.Write(meth.Token());\r
+ }\r
\r
}\r
\r
return false;\r
}\r
\r
- internal sealed override void Write(FileImage output) {\r
- base.Write(output);\r
- output.Write(signature.Token());\r
- }\r
+ internal sealed override void Write(FileImage output) {\r
+ base.Write(output);\r
+ output.Write(signature.Token());\r
+ }\r
}\r
\r
internal class TypeInstr : Instr {\r
internal sealed override void Write(FileImage output) {\r
base.Write(output);\r
output.Write(theType.Token());\r
- }\r
+ }\r
\r
}\r
\r
dest = dst;\r
dest.AddBranch(this);\r
size++;\r
+
+ if (inst >= (int) BranchOp.br && inst != (int) BranchOp.leave_s) {
+ shortVer = false;
+ size += 3;
+ }
}\r
\r
internal sealed override bool Check(MetaData md) {\r
target = (int)dest.GetLabelOffset() - (int)(offset + size);\r
- if (shortVer && ((target < minByteVal) || (target > maxByteVal))) {\r
- if (instr < (int)BranchOp.leave) instr += longInstrOffset;\r
- else instr--;\r
- shortVer = false;\r
- size += 3;\r
- return true;\r
- }\r
- return false;\r
+ return false;
}\r
-\r
- internal sealed override void Write(FileImage output) {\r
- base.Write(output);\r
- if (shortVer)\r
- output.Write((sbyte)target);\r
- else\r
- output.Write(target);\r
- }\r
+
+ internal sealed override void Write(FileImage output) {\r
+ base.Write(output);\r
+ if (shortVer)\r
+ output.Write((sbyte)target);\r
+ else\r
+ output.Write(target);\r
+ }\r
\r
}\r
\r
internal class SwitchInstr : Instr {\r
CILLabel[] cases;\r
- uint numCases = 0;\r
+ uint numCases = 0;\r
\r
internal SwitchInstr(int inst, CILLabel[] dsts) : base(inst) {\r
cases = dsts;\r
- if (cases != null) numCases = (uint)cases.Length;\r
+ if (cases != null) numCases = (uint)cases.Length;\r
size += 4 + (numCases * 4);\r
for (int i=0; i < numCases; i++) {\r
cases[i].AddBranch(this);\r
}\r
}\r
\r
- internal sealed override void Write(FileImage output) {\r
- base.Write(output);\r
- output.Write(numCases);\r
- for (int i=0; i < numCases; i++) {\r
- int target = (int)cases[i].GetLabelOffset() - (int)(offset + size);\r
- output.Write(target);\r
- }\r
- }\r
+ internal sealed override void Write(FileImage output) {\r
+ base.Write(output);\r
+ output.Write(numCases);\r
+ for (int i=0; i < numCases; i++) {\r
+ int target = (int)cases[i].GetLabelOffset() - (int)(offset + size);\r
+ output.Write(target);\r
+ }\r
+ }\r
\r
}\r
/**************************************************************************/ \r
\r
- internal class GenericParameter : MetaDataElement\r
+ public class GenericParameter : MetaDataElement\r
{\r
- ClassDef owner; /* FIXME: can also be a MethodDef */\r
+ MetaDataElement owner;
+ MetaData metadata;
string name;\r
uint nameIx;\r
short index;\r
\r
- public GenericParameter (ClassDef owner, short index) {\r
- this.owner = owner;\r
+ internal GenericParameter (ClassDef owner, MetaData metadata,
+ short index, string name) : this (owner, metadata, index, name, true)
+ {
+ }
+\r
+ internal GenericParameter (MethodDef owner, MetaData metadata,
+ short index, string name) : this (owner, metadata, index, name, true)
+ {
+ }
+
+ private GenericParameter (MetaDataElement owner, MetaData metadata,
+ short index, string name, bool nadda)
+ {
+ this.owner = owner;\r
+ this.metadata = metadata;
this.index = index;\r
tabIx = MDTable.GenericParam;\r
- }\r
-\r
- public GenericParameter (ClassDef owner, short index,\r
- string name) : this (owner, index) {\r
this.name = name;\r
- }\r
-\r
+ }
+
+ public void AddConstraint (Type constraint) {
+ metadata.AddToTable (MDTable.GenericParamConstraint,\r
+ new GenericParamConstraint (this, constraint));\r
+ }
+
internal sealed override uint Size(MetaData md) {\r
return (uint) (4 +\r
md.CodedIndexSize(CIx.TypeOrMethodDef) + \r
\r
internal sealed override void BuildTables(MetaData md) {\r
if (done) return;\r
- if (name == null)\r
- nameIx = 0;\r
- else\r
- nameIx = md.AddToStringsHeap(name);\r
+ nameIx = md.AddToStringsHeap(name);\r
done = true;\r
}\r
\r
\r
\r
}\r
+
+ internal class MethodSpec : MetaDataElement
+ {
+ Method meth;
+ GenericMethodSig g_sig;
+ uint sidx;
+
+ internal MethodSpec (Method meth, GenericMethodSig g_sig) {
+ this.meth = meth;
+ this.g_sig = g_sig;
+ tabIx = MDTable.MethodSpec;
+ }
+
+ internal sealed override void BuildTables (MetaData md) {
+ if (done) return;
+ sidx = g_sig.GetSigIx (md);
+ done = true;
+ }
+
+ internal sealed override uint Size (MetaData md) {
+ return (uint) (md.CodedIndexSize(CIx.MethodDefOrRef) +
+ md.BlobIndexSize ());
+ }
+
+ internal sealed override void Write (FileImage output) {
+ output.WriteCodedIndex (CIx.MethodDefOrRef, meth);
+ output.BlobIndex (sidx);\r
+ }
+ }
+
/**************************************************************************/\r
- /// <summary>\r
- /// Descriptor for interface implemented by a class\r
- /// </summary>\r
- public class InterfaceImpl: MetaDataElement\r
- { \r
+ /// <summary>\r
+ /// Descriptor for interface implemented by a class\r
+ /// </summary>\r
+ public class InterfaceImpl: MetaDataElement\r
+ { \r
ClassDef theClass;\r
Class theInterface;\r
\r
- internal InterfaceImpl(ClassDef theClass, Class theInterface) {\r
+ internal InterfaceImpl(ClassDef theClass, Class theInterface) {\r
this.theClass = theClass;\r
this.theInterface = theInterface;\r
- tabIx = MDTable.InterfaceImpl;\r
- }\r
+ tabIx = MDTable.InterfaceImpl;\r
+ }\r
\r
internal sealed override uint Size(MetaData md) {\r
return md.TableIndexSize(MDTable.TypeDef) + \r
\r
internal sealed override uint GetCodedIx(CIx code) { return 5; }\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for a local of a method\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for a local of a method\r
+ /// </summary>\r
public class Local\r
- {\r
+ {\r
private static readonly byte Pinned = 0x45;\r
string name;\r
Type type;\r
/// <param name="lType">local type</param>\r
/// <param name="byRef">is byref</param>\r
/// <param name="isPinned">has pinned attribute</param>\r
- public Local(string lName, Type lType, bool byRef, bool isPinned)\r
- {\r
+ public Local(string lName, Type lType, bool byRef, bool isPinned)\r
+ {\r
name = lName;\r
type = lType;\r
byref = byRef;\r
pinned = isPinned;\r
- }\r
+ }\r
\r
internal void TypeSig(MemoryStream str) {\r
if (pinned) str.WriteByte(Pinned);\r
type.TypeSig(str);\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for the locals for a method\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for the locals for a method\r
+ /// </summary>\r
\r
public class LocalSig : Signature\r
- {\r
- private static readonly byte LocalSigByte = 0x7;\r
+ {\r
+ private static readonly byte LocalSigByte = 0x7;\r
Local[] locals;\r
\r
- public LocalSig(Local[] locals) {\r
+ public LocalSig(Local[] locals) {\r
this.locals = locals;\r
tabIx = MDTable.StandAloneSig;\r
- }\r
+ }\r
\r
internal sealed override void BuildTables(MetaData md) {\r
if (done) return;\r
}\r
\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for resources used in this PE file NOT YET IMPLEMENTED\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for resources used in this PE file NOT YET IMPLEMENTED\r
+ /// </summary>\r
\r
public class ManifestResource : MetaDataElement\r
- {\r
+ {\r
private static readonly uint PublicResource = 0x1;\r
private static readonly uint PrivateResource = 0x2;\r
\r
\r
internal sealed override uint GetCodedIx(CIx code) { return 18; }\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Base class for elements in the PropertyMap, EventMap and \r
- /// NestedClass MetaData tables\r
- /// </summary>\r
+ /// <summary>\r
+ /// Base class for elements in the PropertyMap, EventMap and \r
+ /// NestedClass MetaData tables\r
+ /// </summary>\r
public class MapElem : MetaDataElement\r
- {\r
+ {\r
ClassDef parent;\r
uint elemIx;\r
MDTable elemTable;\r
\r
- internal MapElem(ClassDef par, uint elIx, MDTable elemTab) {\r
+ internal MapElem(ClassDef par, uint elIx, MDTable elemTab) {\r
parent = par;\r
elemIx = elIx;\r
elemTable = elemTab;\r
- }\r
+ }\r
\r
internal sealed override uint Size(MetaData md) {\r
return md.TableIndexSize(MDTable.TypeDef) + md.TableIndexSize(elemTable);\r
output.WriteIndex(MDTable.TypeDef,parent.Row);\r
output.WriteIndex(elemTable,elemIx);\r
}\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Base class for field/methods (member of a class)\r
- /// </summary>\r
- public abstract class Member : MetaDataElement\r
- {\r
+ /// <summary>\r
+ /// Base class for field/methods (member of a class)\r
+ /// </summary>\r
+ public abstract class Member : MetaDataElement\r
+ {\r
protected string name;\r
protected uint nameIx = 0, sigIx = 0;\r
\r
- internal Member(string memName)\r
- {\r
+ internal Member(string memName)\r
+ {\r
name = memName;\r
- tabIx = MDTable.MemberRef;\r
- }\r
+ tabIx = MDTable.MemberRef;\r
+ }\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
+ /// <summary>\r
/// MetaData \r
/// Root (20 bytes + UTF-8 Version String + quad align padding)\r
/// StreamHeaders (8 bytes + null terminated name string + quad align padding)\r
/// </summary>\r
\r
public class MetaData \r
- {\r
- private static readonly int[] CIxShiftMap = {2,2,5,1,2,3,1,1,1,2,3,2,1};\r
- private static readonly byte StringsHeapMask = 0x1;\r
- private static readonly byte GUIDHeapMask = 0x2;\r
- private static readonly byte BlobHeapMask = 0x4;\r
+ {\r
+ private static readonly int[] CIxShiftMap = {2,2,5,1,2,3,1,1,1,2,3,2,1};\r
+ private static readonly byte StringsHeapMask = 0x1;\r
+ private static readonly byte GUIDHeapMask = 0x2;\r
+ private static readonly byte BlobHeapMask = 0x4;\r
private static readonly uint MetaDataSignature = 0x424A5342;\r
private static readonly uint maxSmlIxSize = 0xFFFF;\r
private static readonly uint max1BitSmlIx = 0x7FFF;\r
private static readonly char[] usName = {'#','U','S','\0'};\r
private static readonly char[] guidName = {'#','G','U','I','D','\0','\0','\0'};\r
private static readonly char[] blobName = {'#','B','l','o','b','\0','\0','\0'};\r
- private static readonly uint MetaDataHeaderSize = 20 + (uint)version.Length;\r
+ private static readonly uint MetaDataHeaderSize = 20 + (uint)version.Length;\r
private static readonly uint TildeHeaderSize = 24;\r
private static readonly uint StreamHeaderSize = 8;\r
private static readonly uint numMetaDataTables = (int)MDTable.GenericParamConstraint + 1;\r
ArrayList[] metaDataTables = new ArrayList[numMetaDataTables];\r
ArrayList byteCodes = new ArrayList();\r
uint codeSize = 0, codeStart, byteCodePadding = 0, metaDataSize = 0;\r
- ulong valid = 0, /*sorted = 0x000002003301FA00;*/ sorted = 0;\r
+ ulong valid = 0, /*sorted = 0x000002003301FA00;*/ sorted = 0;\r
bool[] largeIx = new bool[numMetaDataTables];\r
bool[] lgeCIx = new bool[(int)CIx.MaxCIx];\r
- bool largeStrings = false, largeUS = false, largeGUID = false, largeBlob = false;\r
- private FileImage file;\r
+ bool largeStrings = false, largeUS = false, largeGUID = false, largeBlob = false;\r
+ private FileImage file;\r
private byte heapSizes = 0;\r
- MetaDataElement entryPoint;\r
- BinaryWriter output;\r
+ MetaDataElement entryPoint;\r
+ BinaryWriter output;\r
public MSCorLib mscorlib;\r
private TypeSpec[] systemTypeSpecs = new TypeSpec[PrimitiveType.NumSystemTypes];\r
long mdStart;\r
-\r
+ private ArrayList cattr_list;
+
internal MetaData(FileImage file) {\r
// tilde = new MetaDataStream(tildeName,false,0);\r
this.file = file;\r
- strings = new MetaDataStream(stringsName,new UTF8Encoding(),true);\r
+ strings = new MetaDataStream(stringsName,new UTF8Encoding(),true);\r
us = new MetaDataStream(usName,new UnicodeEncoding(),true);\r
guid = new MetaDataStream(guidName,false);\r
blob = new MetaDataStream(blobName,true);\r
lgeCIx[i] = false;\r
}\r
mscorlib = new MSCorLib(this);\r
- }\r
+ }\r
\r
internal TypeSpec GetPrimitiveTypeSpec(int ix) {\r
return systemTypeSpecs[ix];\r
}\r
\r
internal uint Size() {\r
- //Console.WriteLine("metaData size = " + metaDataSize);\r
return metaDataSize;\r
}\r
\r
- internal void StreamSize(byte mask) {\r
- heapSizes |= mask;\r
- }\r
+ internal void StreamSize(byte mask) {\r
+ heapSizes |= mask;\r
+ }\r
\r
internal uint AddToUSHeap(string str) {\r
if (str == null) return 0;\r
return us.Add(str,true);\r
- }\r
-\r
+ }
+
+ internal uint AddToUSHeap(byte[] str) {
+ if (str == null) return 0;
+ return us.Add (str, true);
+ }
+
internal uint AddToStringsHeap(string str) {\r
if ((str == null) || (str.CompareTo("") == 0)) return 0;\r
return strings.Add(str,false);\r
}\r
\r
internal uint AddToGUIDHeap(Guid guidNum) {\r
- return guid.Add(guidNum);\r
+ return guid.Add(guidNum, false);\r
}\r
\r
internal uint AddToBlobHeap(byte[] blobBytes) {\r
if (blobBytes == null) return 0;\r
- return blob.Add(blobBytes);\r
+ return blob.Add(blobBytes, true);\r
}\r
\r
internal uint AddToBlobHeap(byte val) {\r
- return blob.Add(val);\r
+ return blob.Add(val, true);\r
}\r
\r
internal uint AddToBlobHeap(sbyte val) {\r
- return blob.Add(val);\r
+ return blob.Add(val, true);\r
}\r
\r
internal uint AddToBlobHeap(ushort val) {\r
- return blob.Add(val);\r
+ return blob.Add(val, true);\r
}\r
\r
internal uint AddToBlobHeap(short val) {\r
- return blob.Add(val);\r
+ return blob.Add(val, true);\r
}\r
\r
internal uint AddToBlobHeap(uint val) {\r
- return blob.Add(val);\r
+ return blob.Add(val, true);\r
}\r
\r
internal uint AddToBlobHeap(int val) {\r
- return blob.Add(val);\r
+ return blob.Add(val, true);\r
}\r
\r
internal uint AddToBlobHeap(ulong val) {\r
- return blob.Add(val);\r
+ return blob.Add(val, true);\r
}\r
\r
internal uint AddToBlobHeap(long val) {\r
- return blob.Add(val);\r
+ return blob.Add(val, true);\r
}\r
\r
internal uint AddToBlobHeap(float val) {\r
- return blob.Add(val);\r
+ return blob.Add(val, true);\r
}\r
\r
internal uint AddToBlobHeap(double val) {\r
- return blob.Add(val);\r
+ return blob.Add(val, true);\r
}\r
\r
internal uint AddToBlobHeap(string val) {\r
return blob.Add(val,true);\r
}\r
\r
-\r
+ internal void AddCustomAttribute (CustomAttribute cattr)
+ {
+ if (cattr_list == null)
+ cattr_list = new ArrayList ();
+ cattr_list.Add (cattr);
+ }
+
private ArrayList GetTable(MDTable tableIx) {\r
int tabIx = (int)tableIx;\r
if (metaDataTables[tabIx] == null) {\r
file.AddInitData(cVal);\r
}\r
\r
- internal static void CompressNum(uint val, MemoryStream sig) {\r
- if (val < 0x7F) {\r
- sig.WriteByte((byte)val);\r
- } else if (val < 0x3FFF) {\r
- byte b1 = (byte)((val >> 8) | 0x80);\r
- byte b2 = (byte)(val & FileImage.iByteMask[0]);\r
- sig.WriteByte(b1);\r
- sig.WriteByte(b2);\r
- } else {\r
- byte b1 = (byte)((val >> 24) | 0xC0);\r
- byte b2 = (byte)((val & FileImage.iByteMask[2]) >> 16);\r
- byte b3 = (byte)((val & FileImage.iByteMask[1]) >> 8);;\r
- byte b4 = (byte)(val & FileImage.iByteMask[0]);\r
- sig.WriteByte(b1);\r
- sig.WriteByte(b2);\r
- sig.WriteByte(b3);\r
- sig.WriteByte(b4);\r
- }\r
- }\r
+ internal static void CompressNum(uint val, MemoryStream sig) {\r
+ if (val < 0x7F) {\r
+ sig.WriteByte((byte)val);\r
+ } else if (val < 0x3FFF) {\r
+ byte b1 = (byte)((val >> 8) | 0x80);\r
+ byte b2 = (byte)(val & FileImage.iByteMask[0]);\r
+ sig.WriteByte(b1);\r
+ sig.WriteByte(b2);\r
+ } else {\r
+ byte b1 = (byte)((val >> 24) | 0xC0);\r
+ byte b2 = (byte)((val & FileImage.iByteMask[2]) >> 16);\r
+ byte b3 = (byte)((val & FileImage.iByteMask[1]) >> 8);;\r
+ byte b4 = (byte)(val & FileImage.iByteMask[0]);\r
+ sig.WriteByte(b1);\r
+ sig.WriteByte(b2);\r
+ sig.WriteByte(b3);\r
+ sig.WriteByte(b4);\r
+ }\r
+ }\r
\r
internal uint CodeSize() {\r
return codeSize + byteCodePadding;\r
uint count = (uint)metaDataTables[i].Count;\r
if (count > maxSmlIxSize) {\r
largeIx[i] = true;\r
- MDTable tabIx = (MDTable)i;\r
+ MDTable tabIx = (MDTable)i;\r
if (count > max5BitSmlIx) {\r
lgeCIx[(int)CIx.HasCustomAttr] = true;\r
}\r
}\r
}\r
}\r
- if (strings.LargeIx()) {\r
- largeStrings = true;\r
- heapSizes |= StringsHeapMask;\r
- }\r
- if (guid.LargeIx()) {\r
- largeGUID = true;\r
- heapSizes |= GUIDHeapMask;\r
- }\r
- if (blob.LargeIx()) {\r
- largeBlob = true;\r
- heapSizes |= BlobHeapMask;\r
- }\r
+ if (strings.LargeIx()) {\r
+ largeStrings = true;\r
+ heapSizes |= StringsHeapMask;\r
+ }\r
+ if (guid.LargeIx()) {\r
+ largeGUID = true;\r
+ heapSizes |= GUIDHeapMask;\r
+ }\r
+ if (blob.LargeIx()) {\r
+ largeBlob = true;\r
+ heapSizes |= BlobHeapMask;\r
+ }\r
largeUS = us.LargeIx();\r
}\r
\r
sizeOfHeaders += streams[i].headerSize();\r
}\r
metaDataSize = MetaDataHeaderSize + sizeOfHeaders;\r
- // Console.WriteLine("Size of meta data headers (tildeStart) = " + metaDataSize);\r
tildeStart = metaDataSize;\r
metaDataSize += tildeTide + tildePadding;\r
- //Console.WriteLine(tildeName + " - size = " + (tildeTide + tildePadding));\r
for (int i=1; i < numStreams; i++) {\r
- // Console.WriteLine("Stream " + i + " starts at " + metaDataSize);\r
streams[i].Start = metaDataSize;\r
metaDataSize += streams[i].Size();\r
streams[i].WriteDetails();\r
\r
internal void WriteTildeStream(FileImage output) {\r
long startTilde = output.Seek(0,SeekOrigin.Current);\r
- output.Write((uint)0); // Reserved\r
- output.Write((byte)1); // MajorVersion\r
- output.Write((byte)0); // MinorVersion\r
- output.Write(heapSizes);\r
- output.Write((byte)1); // Reserved\r
- output.Write(valid);\r
- output.Write(sorted);\r
- for (int i=0; i < numMetaDataTables; i++) {\r
- if (metaDataTables[i] != null) {\r
- uint count = (uint)metaDataTables[i].Count;\r
- output.Write(count);\r
- }\r
- }\r
+ output.Write((uint)0); // Reserved\r
+ output.Write((byte)1); // MajorVersion\r
+ output.Write((byte)0); // MinorVersion\r
+ output.Write(heapSizes);\r
+ output.Write((byte)1); // Reserved\r
+ output.Write(valid);\r
+ output.Write(sorted);\r
+ for (int i=0; i < numMetaDataTables; i++) {\r
+ if (metaDataTables[i] != null) {\r
+ uint count = (uint)metaDataTables[i].Count;\r
+ output.Write(count);\r
+ }\r
+ }\r
long tabStart = output.Seek(0,SeekOrigin.Current);\r
// Console.WriteLine("Starting metaData tables at " + tabStart);\r
- for (int i=0; i < numMetaDataTables; i++) {\r
- if (metaDataTables[i] != null) {\r
+ for (int i=0; i < numMetaDataTables; i++) {\r
+ if (metaDataTables[i] != null) {\r
// Console.WriteLine("Starting metaData table " + i + " at " + (output.Seek(0,SeekOrigin.Current) - startTilde));\r
ArrayList table = metaDataTables[i];\r
- for (int j=0; j < table.Count; j++) {\r
+ for (int j=0; j < table.Count; j++) {\r
((MetaDataElement)table[j]).Write(output);\r
- }\r
- }\r
- }\r
+ }\r
+ }\r
+ }\r
// Console.WriteLine("Writing padding at " + output.Seek(0,SeekOrigin.Current));\r
for (int i=0; i < tildePadding; i++) output.Write((byte)0);\r
- }\r
+ }\r
\r
private void BuildTable(ArrayList table) {\r
if (table == null) return;\r
BuildTable(metaDataTables[(int)MDTable.TypeDef]);\r
BuildTable(metaDataTables[(int)MDTable.MemberRef]);\r
BuildTable(metaDataTables[(int)MDTable.GenericParam]);\r
+ BuildTable(metaDataTables[(int)MDTable.MethodSpec]);\r
BuildTable(metaDataTables[(int)MDTable.GenericParamConstraint]);\r
- BuildTable(metaDataTables[(int)MDTable.CustomAttribute]);\r
+
+ if (cattr_list != null) {
+ foreach (CustomAttribute cattr in cattr_list)
+ cattr.BuildTables (this);
+ }
+
/* for (int i=0; i < metaDataTables.Length; i++) {\r
ArrayList table = metaDataTables[i];\r
if (table != null) {\r
}\r
}\r
*/\r
- SetIndexSizes();\r
- for (int i=1; i < numStreams; i++) {\r
- streams[i].EndStream();\r
- }\r
- CalcTildeStreamSize();\r
- SetStreamOffsets();\r
+
+ SetIndexSizes();\r
+ for (int i=1; i < numStreams; i++) {\r
+ streams[i].EndStream();\r
+ }\r
+ CalcTildeStreamSize();\r
+ SetStreamOffsets();\r
byteCodePadding = NumToAlign(codeSize,4);\r
if (entryPoint != null) file.SetEntryPoint(entryPoint.Token());\r
}\r
}\r
\r
internal void WriteMetaData(FileImage output) {\r
- this.output = output;\r
+ this.output = output;\r
mdStart = output.Seek(0,SeekOrigin.Current);\r
// Console.WriteLine("Writing metaData at " + Hex.Long(mdStart));\r
output.Write(MetaDataSignature);\r
// Console.WriteLine("Finished Writing metaData at " + output.Seek(0,SeekOrigin.Current));\r
}\r
\r
- internal bool LargeStringsIndex() { return strings.LargeIx(); }\r
- internal bool LargeGUIDIndex() { return guid.LargeIx(); }\r
- internal bool LargeUSIndex() { return us.LargeIx(); }\r
- internal bool LargeBlobIndex() { return blob.LargeIx(); }\r
+ internal bool LargeStringsIndex() { return strings.LargeIx(); }\r
+ internal bool LargeGUIDIndex() { return guid.LargeIx(); }\r
+ internal bool LargeUSIndex() { return us.LargeIx(); }\r
+ internal bool LargeBlobIndex() { return blob.LargeIx(); }\r
\r
internal bool LargeIx(MDTable tabIx) { return largeIx[(uint)tabIx]; }\r
\r
\r
- private uint NumToAlign(uint val, uint alignVal) {\r
- if ((val % alignVal) == 0) return 0;\r
- return alignVal - (val % alignVal);\r
- }\r
+ private uint NumToAlign(uint val, uint alignVal) {\r
+ if ((val % alignVal) == 0) return 0;\r
+ return alignVal - (val % alignVal);\r
+ }\r
\r
internal void WriteCodedIndex(CIx code, MetaDataElement elem, FileImage output) {\r
uint ix = 0;\r
output.Write((ushort)ix);\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Base class for all Meta Data table elements\r
- /// </summary>\r
+ /// <summary>\r
+ /// Base class for all Meta Data table elements\r
+ /// </summary>\r
\r
public abstract class MetaDataElement\r
- {\r
+ {\r
\r
protected ArrayList customAttributes;\r
private uint row = 0;\r
protected bool done = false;\r
- protected MDTable tabIx;\r
+ protected MDTable tabIx;\r
\r
internal MetaDataElement() { }\r
\r
} \r
// customAttributes.Add(new CustomAttribute(this,ctorMeth,cVals));\r
}\r
-\r
- internal void DoCustomAttributes(MetaData md) {\r
- if (customAttributes != null) {\r
- for (int i=0; i < customAttributes.Count; i++) {\r
- CustomAttribute ca = (CustomAttribute)customAttributes[i];\r
- ca.BuildTables(md);\r
- }\r
- }\r
- }\r
-\r
+
internal uint Token() {\r
return (((uint)tabIx << 24) | row);\r
}\r
\r
internal virtual void Write(FileImage output) { }\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Stream in the Meta Data (#Strings, #US, #Blob and #GUID)\r
- /// </summary>\r
+ /// <summary>\r
+ /// Stream in the Meta Data (#Strings, #US, #Blob and #GUID)\r
+ /// </summary>\r
\r
internal class MetaDataStream : BinaryWriter \r
- {\r
- private static readonly uint StreamHeaderSize = 8;\r
- private static uint maxSmlIxSize = 0xFFFF;\r
- \r
+ {\r
+ private static readonly uint StreamHeaderSize = 8;\r
+ private static uint maxSmlIxSize = 0xFFFF;\r
+ \r
private uint start = 0; \r
uint size = 0, tide = 1;\r
bool largeIx = false;\r
uint sizeOfHeader;\r
char[] name;\r
- Hashtable htable = new Hashtable();\r
-\r
+ Hashtable htable = new Hashtable();
+ Hashtable btable = new Hashtable ();
+
internal MetaDataStream(char[] name, bool addInitByte) : base(new MemoryStream()) {\r
if (addInitByte) { Write((byte)0); size = 1; }\r
this.name = name;\r
if (addInitByte) { Write((byte)0); size = 1; }\r
this.name = name;\r
sizeOfHeader = StreamHeaderSize + (uint)name.Length;\r
- }\r
+ }\r
\r
public uint Start {\r
get {\r
// Console.WriteLine(name + " - size = " + size);\r
}\r
\r
- internal uint Add(string str, bool prependSize) {\r
+ internal uint Add(string str, bool prependSize) {\r
Object val = htable[str];\r
uint index = 0;\r
if (val == null) { \r
} else {\r
index = (uint)val;\r
}\r
- return index;\r
- }\r
-\r
- internal uint Add(Guid guid) {\r
- Write(guid.ToByteArray());\r
- size =(uint)Seek(0,SeekOrigin.Current);\r
- return tide++;\r
- }\r
-\r
- internal uint Add(byte[] blob) {\r
- uint ix = size;\r
- CompressNum((uint)blob.Length);\r
- Write(blob);\r
- size = (uint)Seek(0,SeekOrigin.Current);\r
- return ix;\r
- }\r
-\r
- internal uint Add(byte val) {\r
+ return index;\r
+ }
+ internal uint Add (byte[] str, bool prependSize) {
+ Object val = btable [str];
+ uint index = 0;
+ if (val == null) {
+ index = size;
+ btable [str] = index;
+ if (prependSize) CompressNum ((uint) str.Length);
+ Write (str);
+ size = (uint) Seek (0, SeekOrigin.Current);
+ } else {
+ index = (uint) val;
+ }
+ return index;
+ }
+
+
+ internal uint Add(Guid guid, bool prependSize) {\r
+ byte [] b = guid.ToByteArray ();
+ if (prependSize) CompressNum ((uint) b.Length);
+ Write(guid.ToByteArray());\r
+ size =(uint)Seek(0,SeekOrigin.Current);\r
+ return tide++;\r
+ }\r
+\r
+ internal uint Add(byte[] blob) {\r
+ uint ix = size;\r
+ CompressNum((uint)blob.Length);
+ Write(blob);\r
+ size = (uint)Seek(0,SeekOrigin.Current);\r
+ return ix;\r
+ }\r
+\r
+ internal uint Add(byte val, bool prependSize) {\r
uint ix = size;\r
+ if (prependSize) CompressNum (1);
Write(val);\r
size = (uint)Seek(0,SeekOrigin.Current);\r
return ix;\r
}\r
\r
- internal uint Add(sbyte val) {\r
+ internal uint Add(sbyte val, bool prependSize) {\r
uint ix = size;\r
+ if (prependSize) CompressNum (1);
Write(val);\r
size = (uint)Seek(0,SeekOrigin.Current);\r
return ix;\r
}\r
\r
- internal uint Add(ushort val) {\r
+ internal uint Add(ushort val, bool prependSize) {\r
uint ix = size;\r
+ if (prependSize) CompressNum (2);
Write(val);\r
size = (uint)Seek(0,SeekOrigin.Current);\r
return ix;\r
}\r
\r
- internal uint Add(short val) {\r
+ internal uint Add(short val, bool prependSize) {\r
uint ix = size;\r
+ if (prependSize) CompressNum (2);
Write(val);\r
size = (uint)Seek(0,SeekOrigin.Current);\r
return ix;\r
}\r
\r
- internal uint Add(uint val) {\r
+ internal uint Add(uint val, bool prependSize) {\r
uint ix = size;\r
+ if (prependSize) CompressNum (4);
Write(val);\r
size = (uint)Seek(0,SeekOrigin.Current);\r
return ix;\r
}\r
\r
- internal uint Add(int val) {\r
+ internal uint Add(int val, bool prependSize) {\r
uint ix = size;\r
- Write(val);\r
+ if (prependSize) CompressNum (4);
+ Write (val);
size = (uint)Seek(0,SeekOrigin.Current);\r
return ix;\r
}\r
\r
- internal uint Add(ulong val) {\r
+ internal uint Add(ulong val, bool prependSize) {\r
uint ix = size;\r
+ if (prependSize) CompressNum (8);
Write(val);\r
size = (uint)Seek(0,SeekOrigin.Current);\r
return ix;\r
}\r
\r
- internal uint Add(long val) {\r
+ internal uint Add(long val, bool prependSize) {\r
uint ix = size;\r
+ if (prependSize) CompressNum (8);
Write(val);\r
size = (uint)Seek(0,SeekOrigin.Current);\r
return ix;\r
}\r
\r
- internal uint Add(float val) {\r
+ internal uint Add(float val, bool prependSize) {\r
uint ix = size;\r
+ if (prependSize) CompressNum (4);
Write(val);\r
size = (uint)Seek(0,SeekOrigin.Current);\r
return ix;\r
}\r
\r
- internal uint Add(double val) {\r
+ internal uint Add(double val, bool prependSize) {\r
uint ix = size;\r
+ if (prependSize) CompressNum (8);
Write(val);\r
size = (uint)Seek(0,SeekOrigin.Current);\r
return ix;\r
}\r
\r
- private void CompressNum(uint val) {\r
+ private void CompressNum(uint val) {\r
if (val < 0x7F) {\r
Write((byte)val);\r
} else if (val < 0x3FFF) {\r
}\r
}\r
\r
- internal void EndStream() {\r
- QuadAlign();\r
- if (size > maxSmlIxSize) {\r
- largeIx = true;\r
- }\r
- }\r
+ internal void EndStream() {\r
+ QuadAlign();\r
+ if (size > maxSmlIxSize) {\r
+ largeIx = true;\r
+ }\r
+ }\r
\r
internal void WriteHeader(BinaryWriter output) {\r
output.Write(start);\r
output.Write(name);\r
}\r
\r
- internal virtual void Write(BinaryWriter output) {\r
+ internal virtual void Write(BinaryWriter output) {\r
// Console.WriteLine("Writing " + name + " stream at " + output.Seek(0,SeekOrigin.Current) + " = " + start);\r
MemoryStream str = (MemoryStream)BaseStream;\r
- output.Write(str.ToArray());\r
- }\r
+ output.Write(str.ToArray());\r
+ }\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Base class for Method Descriptors\r
- /// </summary>\r
+ /// <summary>\r
+ /// Base class for Method Descriptors\r
+ /// </summary>\r
\r
public abstract class Method : Member\r
- {\r
+ {\r
protected CallConv callConv = CallConv.Default;\r
protected Type retType;\r
\r
internal Method(string methName, Type rType) : base(methName)\r
- {\r
+ {\r
retType = rType;\r
- }\r
+ }\r
\r
/// <summary>\r
/// Add calling conventions to this method descriptor\r
callConv |= cconv;\r
}\r
\r
- internal abstract void TypeSig(MemoryStream sig);\r
+ internal abstract void TypeSig(MemoryStream sig);\r
\r
internal uint GetSigIx(MetaData md) {\r
MemoryStream sig = new MemoryStream();\r
- TypeSig(sig);\r
+ TypeSig(sig);\r
return md.AddToBlobHeap(sig.ToArray());\r
}\r
\r
return retType;\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for a method defined in THIS assembly/module\r
- /// IL .method\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for a method defined in THIS assembly/module\r
+ /// IL .method\r
+ /// </summary>\r
\r
public class MethodDef : Method\r
- {\r
+ {\r
private static readonly ushort PInvokeImpl = 0x2000;\r
//private static readonly uint UnmanagedExport = 0x0008;\r
// private static readonly byte LocalSigByte = 0x7;\r
MetaData metaData;\r
CILInstructions code;\r
ArrayList securityActions = new ArrayList();\r
- Param[] parList;\r
+ Param[] parList;\r
Local[] locals;\r
bool initLocals;\r
ushort methFlags = 0, implFlags = 0;\r
ImplMap pinvokeImpl;\r
\r
\r
- internal MethodDef(MetaData md, string name, Type retType, Param[] pars) : base(name,retType) {\r
+ internal MethodDef(MetaData md, string name, Type retType, Param[] pars) : base(name,retType) {\r
metaData = md;\r
- parList = pars;\r
- if (parList != null) numPars = parList.Length;\r
+ parList = pars;\r
+ if (parList != null) numPars = parList.Length;\r
tabIx = MDTable.Method;\r
- }\r
+ }\r
\r
internal MethodDef(MetaData md, MethAttr mAttrSet, ImplAttr iAttrSet, string name, Type retType, Param[] pars) : base(name,retType) {\r
metaData = md;\r
- parList = pars;\r
- if (parList != null) numPars = parList.Length;\r
+ parList = pars;\r
+ if (parList != null) numPars = parList.Length;\r
// Console.WriteLine("Creating method " + name + " with " + numPars + " parameters");\r
- methFlags = (ushort)mAttrSet;\r
+ methFlags = (ushort)mAttrSet;\r
implFlags = (ushort)iAttrSet;\r
tabIx = MDTable.Method;\r
}\r
\r
- internal Param[] GetPars() {\r
- return parList;\r
- }\r
+ internal Param[] GetPars() {\r
+ return parList;\r
+ }\r
\r
/// <summary>\r
/// Add some attributes to this method descriptor\r
methFlags |= PInvokeImpl;\r
}\r
\r
+ /// <summary>\r
+ /// Add a named generic type parameter\r
+ /// </summary>\r
+ public GenericParameter AddGenericParameter (short index, string name) {\r
+ GenericParameter gp = new GenericParameter (this, metaData, index, name);
+ metaData.AddToTable (MDTable.GenericParam, gp);\r
+ return gp;
+ }\r
+
/// <summary>\r
/// Set the maximum stack height for this method\r
/// </summary>\r
return varArgSig;\r
}\r
\r
- internal sealed override void TypeSig(MemoryStream sig) {\r
- sig.WriteByte((byte)callConv);\r
- MetaData.CompressNum((uint)numPars,sig);\r
- retType.TypeSig(sig);\r
- for (ushort i=0; i < numPars; i++) {\r
- parList[i].seqNo = (ushort)(i+1);\r
- parList[i].TypeSig(sig);\r
- }\r
- }\r
+ internal sealed override void TypeSig(MemoryStream sig) {\r
+ sig.WriteByte((byte)callConv);\r
+ MetaData.CompressNum((uint)numPars,sig);\r
+ retType.TypeSig(sig);\r
+ for (ushort i=0; i < numPars; i++) {\r
+ parList[i].seqNo = (ushort)(i+1);\r
+ parList[i].TypeSig(sig);\r
+ }\r
+ }\r
\r
internal sealed override void BuildTables(MetaData md) {\r
if (done) return;\r
localSig.BuildTables(md);\r
locToken = localSig.Token();\r
}\r
- if (code != null) {\r
- code.CheckCode(locToken,initLocals,maxStack);\r
- textOffset = md.AddCode(code);\r
- }\r
+ if (code != null) {\r
+ code.CheckCode(locToken,initLocals,maxStack);\r
+ textOffset = md.AddCode(code);\r
+ }\r
nameIx = md.AddToStringsHeap(name);\r
sigIx = GetSigIx(md);\r
parIx = md.TableIndex(MDTable.Param);\r
- for (int i=0; i < numPars; i++) {\r
- md.AddToTable(MDTable.Param,parList[i]);\r
- parList[i].BuildTables(md);\r
- }\r
+ for (int i=0; i < numPars; i++) {\r
+ md.AddToTable(MDTable.Param,parList[i]);\r
+ parList[i].BuildTables(md);\r
+ }\r
if (varArgSigList != null) {\r
foreach (MethodRef varArgSig in varArgSigList) {\r
md.AddToTable(MDTable.MemberRef,varArgSig);\r
varArgSig.BuildTables(md);\r
}\r
}\r
- DoCustomAttributes (md);\r
// Console.WriteLine("method has " + numPars + " parameters");\r
done = true;\r
}\r
}\r
\r
internal sealed override void Write(FileImage output) {\r
- if (code == null) output.Write(0);\r
+ if (ZeroRva ()) output.Write(0);\r
else output.WriteCodeRVA(textOffset);\r
output.Write(implFlags);\r
output.Write(methFlags);\r
output.WriteIndex(MDTable.Param,parIx);\r
}\r
\r
+ internal bool ZeroRva () {
+ return (((methFlags & (ushort)MethAttr.Abstract) != 0) ||
+ ((implFlags & (ushort)ImplAttr.Runtime) != 0) ||
+ ((implFlags & (ushort)ImplAttr.InternalCall) != 0) ||
+ (pinvokeImpl != null)); // TODO: Not entirely true but works for now
+ }
+
internal sealed override uint GetCodedIx(CIx code) {\r
- switch (code) {\r
- case (CIx.HasCustomAttr) : return 0; \r
- case (CIx.HasDeclSecurity) : return 1; \r
- case (CIx.MemberRefParent) : return 3; \r
- case (CIx.MethodDefOrRef) : return 0; \r
- case (CIx.MemberForwarded) : return 1; \r
- case (CIx.CustomAttributeType) : return 2; \r
- case (CIx.TypeOrMethodDef) : return 1; \r
- }\r
- return 0;\r
- }\r
-\r
- }\r
+ switch (code) {\r
+ case (CIx.HasCustomAttr) : return 0; \r
+ case (CIx.HasDeclSecurity) : return 1; \r
+ case (CIx.MemberRefParent) : return 3; \r
+ case (CIx.MethodDefOrRef) : return 0; \r
+ case (CIx.MemberForwarded) : return 1; \r
+ case (CIx.CustomAttributeType) : return 2; \r
+ case (CIx.TypeOrMethodDef) : return 1; \r
+ }\r
+ return 0;\r
+ }\r
+\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for an overriding method (.override)\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for an overriding method (.override)\r
+ /// </summary>\r
public class MethodImpl : MetaDataElement\r
- {\r
+ {\r
ClassDef parent;\r
Method header, body;\r
\r
- internal MethodImpl(ClassDef par, Method decl, Method bod) {\r
+ internal MethodImpl(ClassDef par, Method decl, Method bod) {\r
parent = par;\r
header = decl;\r
body = bod;\r
- tabIx = MDTable.MethodImpl;\r
- }\r
+ tabIx = MDTable.MethodImpl;\r
+ }\r
\r
internal sealed override uint Size(MetaData md) {\r
return md.TableIndexSize(MDTable.TypeDef) + 2 * md.CodedIndexSize(CIx.MethodDefOrRef);\r
output.WriteCodedIndex(CIx.MethodDefOrRef,header);\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for a method defined in another assembly/module\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for a method defined in another assembly/module\r
+ /// </summary>\r
public class MethodRef : Method\r
{\r
private static readonly byte Sentinel = 0x41;\r
- Type[] parList, optParList;\r
+ Type[] parList, optParList;\r
MetaDataElement parent;\r
uint numPars = 0, numOptPars = 0;\r
\r
}\r
}\r
\r
- internal sealed override void TypeSig(MemoryStream sig) {\r
- sig.WriteByte((byte)callConv);\r
- MetaData.CompressNum(numPars+numOptPars,sig);\r
- retType.TypeSig(sig);\r
- for (int i=0; i < numPars; i++) {\r
- parList[i].TypeSig(sig);\r
- }\r
+ internal sealed override void TypeSig(MemoryStream sig) {\r
+ sig.WriteByte((byte)callConv);\r
+ MetaData.CompressNum(numPars+numOptPars,sig);\r
+ retType.TypeSig(sig);\r
+ for (int i=0; i < numPars; i++) {\r
+ parList[i].TypeSig(sig);\r
+ }\r
if (numOptPars > 0) {\r
sig.WriteByte(Sentinel);\r
for (int i=0; i < numOptPars; i++) {\r
optParList[i].TypeSig(sig);\r
}\r
}\r
- }\r
+ }\r
\r
internal sealed override void BuildTables(MetaData md) {\r
if (done) return;\r
case (CIx.MethodDefOrRef) : return 1; \r
case (CIx.CustomAttributeType) : return 3; \r
}\r
- return 0;\r
+ return 0;\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for Property and Event methods\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for Property and Event methods\r
+ /// </summary>\r
public class MethodSemantics : MetaDataElement {\r
\r
Feature.MethodType type;\r
type = mType;\r
meth = method;\r
eventOrProp = feature;\r
- tabIx = MDTable.MethodSemantics;\r
- }\r
+ tabIx = MDTable.MethodSemantics;\r
+ }\r
\r
internal sealed override uint Size(MetaData md) {\r
return 2 + md.TableIndexSize(MDTable.Method) + md.CodedIndexSize(CIx.HasSemantics);\r
output.WriteCodedIndex(CIx.HasSemantics,eventOrProp);\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for a FunctionPointer type\r
- /// </summary>\r
- /// \r
- public class MethPtrType : Type\r
- {\r
- // MethPtrType == FNPTR\r
- Method method;\r
- uint sigIx = 0;\r
-\r
+ /// <summary>\r
+ /// Descriptor for a FunctionPointer type\r
+ /// </summary>\r
+ /// \r
+ public class MethPtrType : Type\r
+ {\r
+ bool varArgMeth;
+ Type retType;
+ Type [] parList;
+ Type [] optParList;
+ CallConv callConv;
+ uint numPars;
+ uint numOptPars;
+ uint sigIx = 0;
+
/// <summary>\r
/// Create a new function pointer type\r
/// </summary>\r
/// <param name="meth">the function to be referenced</param>\r
- public MethPtrType(Method meth) : base(0x1B)\r
- {\r
- method = meth;\r
- tabIx = MDTable.TypeSpec;\r
- }\r
-\r
- internal sealed override void TypeSig(MemoryStream str) {\r
- str.WriteByte(typeIndex);\r
- method.TypeSig(str);\r
- }\r
-\r
+ public MethPtrType (CallConv callconv, Type retType, Type[] pars,
+ bool varArgMeth, Type[] optPars) : base(0x1B) {
+ this.retType = retType;
+ callConv = callconv;
+ parList = pars;
+ this.varArgMeth = varArgMeth;
+ if (parList != null) numPars = (uint)parList.Length;
+ if (varArgMeth) {
+ optParList = optPars;
+ if (optParList != null) numOptPars = (uint)optParList.Length;
+ callConv |= CallConv.Vararg;
+ }
+ tabIx = MDTable.TypeSpec;
+ }
+
+ internal sealed override void TypeSig(MemoryStream sig) {
+ sig.WriteByte(typeIndex);
+ // Bootlegged from method ref
+ sig.WriteByte((byte)callConv);
+ MetaData.CompressNum (numPars + numOptPars, sig);
+ retType.TypeSig (sig);
+ for (int i=0; i < numPars; i++) {
+ parList[i].TypeSig (sig);
+ }
+ if (varArgMeth) {
+ sig.WriteByte (0x41); // Write the sentinel
+ for (int i=0; i < numOptPars; i++) {
+ optParList[i].TypeSig (sig);
+ }
+ }
+ }
+
internal sealed override void BuildTables(MetaData md) {\r
if (done) return;\r
MemoryStream sig = new MemoryStream();\r
done = true;\r
}\r
\r
- internal sealed override uint Size(MetaData md) {\r
- return md.BlobIndexSize();\r
- }\r
+ internal sealed override uint Size(MetaData md) {\r
+ return md.BlobIndexSize();\r
+ }\r
\r
- internal sealed override void Write(FileImage output) {\r
- output.BlobIndex(sigIx);\r
- }\r
+ internal sealed override void Write(FileImage output) {\r
+ output.BlobIndex(sigIx);\r
+ }\r
\r
- internal sealed override uint GetCodedIx(CIx code) { return 0x1B; }\r
+ internal sealed override uint GetCodedIx(CIx code) { return 0x1B; }\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for THIS module\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for THIS module\r
+ /// </summary>\r
public class Module : ResolutionScope\r
- {\r
+ {\r
Guid mvid;\r
uint mvidIx = 0;\r
\r
- internal Module(string name, MetaData md) : base(name,md) {\r
+ internal Module(string name, MetaData md) : base(name,md) {\r
mvid = Guid.NewGuid();\r
mvidIx = md.AddToGUIDHeap(mvid);\r
tabIx = MDTable.Module;\r
}\r
\r
internal sealed override uint GetCodedIx(CIx code) {\r
- switch (code) {\r
- case (CIx.HasCustomAttr) : return 7; \r
- case (CIx.ResolutionScope) : return 0;\r
- }\r
- return 0;\r
+ switch (code) {\r
+ case (CIx.HasCustomAttr) : return 7; \r
+ case (CIx.ResolutionScope) : return 0;\r
+ }\r
+ return 0;\r
}\r
-\r
- }\r
+ }
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for another module in THIS assembly\r
- /// </summary>\r
- public class ModuleRef : ResolutionScope\r
- {\r
+ /// <summary>\r
+ /// Descriptor for another module in THIS assembly\r
+ /// </summary>\r
+ public class ModuleRef : ResolutionScope, IExternRef
+ {\r
\r
- internal ModuleRef(MetaData md, string name) : base(name,md) {\r
+ internal ModuleRef(MetaData md, string name) : base(name,md) {\r
tabIx = MDTable.ModuleRef;\r
- }\r
-\r
+ }
+
/// <summary>\r
/// Add a class to this external module. This is a class declared in\r
/// another module of THIS assembly.\r
/// <param name="nsName">name space name</param>\r
/// <param name="name">class name</param>\r
/// <returns>a descriptor for this class in another module</returns>\r
- public ClassRef AddClass(string nsName, string name, bool exportClass) {\r
+ public ClassRef AddClass(string nsName, string name) {\r
ClassRef aClass = new ClassRef(nsName,name,metaData);\r
metaData.AddToTable(MDTable.TypeRef,aClass);\r
aClass.SetParent(this);\r
case (CIx.MemberRefParent) : return 2; \r
case (CIx.ResolutionScope) : return 1; \r
}\r
- return 0;\r
+ return 0;\r
}\r
\r
}\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptors for native types used for marshalling\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptors for native types used for marshalling\r
+ /// </summary>\r
public class NativeType {\r
public static readonly NativeType Void = new NativeType(0x01);\r
public static readonly NativeType Boolean = new NativeType(0x02);\r
}\r
\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for a parameter of a method defined in this assembly/module\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for a parameter of a method defined in this assembly/module\r
+ /// </summary>\r
public class Param : MetaDataElement\r
- {\r
+ {\r
private static readonly ushort hasDefault = 0x1000;\r
private static readonly ushort hasFieldMarshal = 0x2000;\r
\r
pName = parName;\r
pType = parType;\r
parMode = (ushort)mode;\r
- tabIx = MDTable.Param;\r
- }\r
+ tabIx = MDTable.Param;\r
+ }\r
\r
/// <summary>\r
/// Add a default value to this parameter\r
case (CIx.HasConst) : return 1; \r
case (CIx.HasFieldMarshal) : return 1; \r
}\r
- return 0;\r
+ return 0;\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Base class for the PEFile (starting point)\r
- /// </summary>\r
+ /// <summary>\r
+ /// Base class for the PEFile (starting point)\r
+ /// </summary>\r
public class PEFile\r
- {\r
+ {\r
private static readonly string mscorlibName = "mscorlib";\r
private Module thisMod;\r
private ClassDef moduleClass;\r
private Assembly thisAssembly;\r
private int corFlags = 1;\r
FileImage fileImage;\r
- MetaData metaData;\r
+ MetaData metaData;\r
\r
/// <summary>\r
/// Create a new PEFile. Each PEFile is a module.\r
// Console.WriteLine(Hex.Short(0x1234));\r
// Console.WriteLine(Hex.Int(0x12345678));\r
string fName = MakeFileName(outputDir,name,isDLL);\r
- fileImage = new FileImage(isDLL,fName);\r
+ fileImage = new FileImage(isDLL,fName);\r
InitPEFile(name, fName, hasAssembly);\r
}\r
\r
fileImage = new FileImage(isDLL,outStream);\r
InitPEFile(name, MakeFileName(null,name,isDLL), hasAssembly);\r
}\r
-\r
+
+ public PEFile(string name, string module_name, bool isDLL, bool hasAssembly, Stream outStream) {\r
+ fileImage = new FileImage(isDLL,outStream);\r
+ InitPEFile(name, (module_name == null ? MakeFileName(null,name,isDLL) : module_name), hasAssembly);\r
+ }
+
private void InitPEFile(string name, string fName, bool hasAssembly) {\r
metaData = fileImage.GetMetaData();\r
thisMod = new Module(fName,metaData);\r
metaData.AddToTable(MDTable.Module,thisMod);\r
}\r
\r
+
+ public ClassDef ModuleClass {
+ get { return moduleClass; }
+ }
+
/// <summary>\r
/// Set the subsystem (.subsystem) (Default is Windows Console mode)\r
/// </summary>\r
return field;\r
}\r
\r
+ public void AddMethodSpec (Method m, GenericMethodSig g_sig)
+ {
+ MethodSpec ms = new MethodSpec (m, g_sig);
+ metaData.AddToTable (MDTable.MethodSpec, ms);
+ }
+
/// <summary>\r
/// Add a "global" field to this module\r
/// </summary>\r
metaData.AddToTable(MDTable.ManifestResource,mr);\r
//mr.FixName(metaData);\r
}\r
-\r
+
+ public void AddCustomAttribute (Method meth, byte [] data, MetaDataElement element)
+ {
+ metaData.AddCustomAttribute (new CustomAttribute (element, meth, data));
+ }
+
/// <summary>\r
/// Write out the PEFile (the "bake" function)\r
/// </summary>\r
return thisAssembly;\r
}\r
\r
- }\r
+ }\r
\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for the Primitive types defined in IL\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for the Primitive types defined in IL\r
+ /// </summary>\r
public class PrimitiveType : Type\r
- {\r
+ {\r
private string name;\r
private int systemTypeIndex;\r
public static int NumSystemTypes = 18;\r
public static readonly PrimitiveType Float32 = new PrimitiveType(0x0C,"Single",11);\r
public static readonly PrimitiveType Float64 = new PrimitiveType(0x0D,"Double",12);\r
public static readonly PrimitiveType String = new PrimitiveType(0x0E,"String",13);\r
- internal static readonly PrimitiveType Class = new PrimitiveType(0x12);\r
+ internal static readonly PrimitiveType Class = new PrimitiveType(0x12);\r
public static readonly PrimitiveType TypedRef = new PrimitiveType(0x16,"TypedReference",14);\r
public static readonly PrimitiveType IntPtr = new PrimitiveType(0x18,"IntPtr",15);\r
public static readonly PrimitiveType UIntPtr = new PrimitiveType(0x19,"UIntPtr",16);\r
\r
internal PrimitiveType(byte typeIx) : base(typeIx) { }\r
\r
- internal PrimitiveType(byte typeIx, string name, int STIx) : base(typeIx) {\r
+ internal PrimitiveType(byte typeIx, string name, int STIx) : base(typeIx) {\r
this.name = name;\r
this.systemTypeIndex = STIx;\r
}\r
return tS;\r
}\r
\r
- }\r
+ }\r
\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for the Property of a class\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for the Property of a class\r
+ /// </summary>\r
public class Property : Feature\r
- {\r
+ {\r
private static readonly byte PropertyTag = 0x8;\r
MethodDef getterMeth;\r
ConstantElem constVal;\r
returnType = retType;\r
parList = pars;\r
if (pars != null) numPars = (uint)pars.Length;\r
- tabIx = MDTable.Property;\r
- }\r
+ tabIx = MDTable.Property;\r
+ }\r
\r
/// <summary>\r
/// Add a set method to this property\r
}\r
\r
internal sealed override uint GetCodedIx(CIx code) {\r
- switch (code) {\r
- case (CIx.HasCustomAttr) : return 9; \r
- case (CIx.HasConst) : return 2; \r
- case (CIx.HasSemantics) : return 1; \r
- }\r
- return 0;\r
+ switch (code) {\r
+ case (CIx.HasCustomAttr) : return 9; \r
+ case (CIx.HasConst) : return 2; \r
+ case (CIx.HasSemantics) : return 1; \r
+ }\r
+ return 0;\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for an pointer (type * or type &)\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for an pointer (type * or type &)\r
+ /// </summary>\r
public abstract class PtrType : Type\r
- {\r
+ {\r
Type baseType;\r
\r
- internal PtrType(Type bType, byte typeIx) : base(typeIx)\r
- {\r
+ internal PtrType(Type bType, byte typeIx) : base(typeIx)\r
+ {\r
baseType = bType;\r
tabIx = MDTable.TypeSpec;\r
- }\r
+ }\r
\r
internal sealed override void TypeSig(MemoryStream str) {\r
str.WriteByte(typeIndex);\r
baseType.TypeSig(str);\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
/// <summary>\r
/// Descriptor for a managed pointer (type & or byref)\r
\r
}\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Base class for scopes (extended by Module, ModuleRef, Assembly, AssemblyRef)\r
- /// </summary>\r
+ /// <summary>\r
+ /// Base class for scopes (extended by Module, ModuleRef, Assembly, AssemblyRef)\r
+ /// </summary>\r
public abstract class ResolutionScope : MetaDataElement\r
- {\r
+ {\r
protected uint nameIx = 0;\r
protected MetaData metaData;\r
protected string name;\r
\r
- internal ResolutionScope(string name, MetaData md)\r
- {\r
+ internal ResolutionScope(string name, MetaData md)\r
+ {\r
metaData = md;\r
this.name = name;\r
nameIx = md.AddToStringsHeap(name);\r
- }\r
+ }\r
\r
internal string GetName() { return name; }\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for a Section in a PEFile eg .text, .sdata\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for a Section in a PEFile eg .text, .sdata\r
+ /// </summary>\r
internal class Section {\r
- private static readonly uint relocPageSize = 4096; // 4K pages for fixups\r
+ private static readonly uint relocPageSize = 4096; // 4K pages for fixups\r
\r
- char[] name; \r
- uint offset = 0, tide = 0, size = 0, rva = 0, relocTide = 0;\r
- //uint relocOff = 0;\r
+ char[] name; \r
+ uint offset = 0, tide = 0, size = 0, rva = 0, relocTide = 0;\r
+ //uint relocOff = 0;\r
uint flags = 0, padding = 0;\r
- uint[] relocs; \r
+ uint[] relocs; \r
\r
- internal Section(string sName, uint sFlags) {\r
- name = sName.ToCharArray();\r
- flags = sFlags;\r
- }\r
+ internal Section(string sName, uint sFlags) {
+ name = sName.ToCharArray();\r
+ flags = sFlags;\r
+ }
\r
- internal uint Tide() { return tide; }\r
+ internal uint Tide() { return tide; }\r
\r
- internal void IncTide(uint incVal) { tide += incVal; }\r
+ internal void IncTide(uint incVal) { tide += incVal; }\r
\r
- internal uint Padding() { return padding; }\r
+ internal uint Padding() { return padding; }\r
\r
- internal uint Size() { return size; }\r
+ internal uint Size() { return size; }\r
\r
- internal void SetSize(uint pad) {\r
- padding = pad;\r
- size = tide + padding;\r
- }\r
+ internal void SetSize(uint pad) {\r
+ padding = pad;\r
+ size = tide + padding;\r
+ }\r
\r
- internal uint RVA() { return rva; }\r
+ internal uint RVA() { return rva; }\r
\r
- internal void SetRVA(uint rva) { this.rva = rva; }\r
+ internal void SetRVA(uint rva) { this.rva = rva; }\r
\r
- internal uint Offset() { return offset; }\r
+ internal uint Offset() { return offset; }\r
\r
- internal void SetOffset(uint offs) { offset = offs; }\r
+ internal void SetOffset(uint offs) { offset = offs; }\r
\r
internal void DoBlock(BinaryWriter reloc, uint page, int start, int end) {\r
//Console.WriteLine("rva = " + rva + " page = " + page);\r
reloc.Write((ushort)0);\r
}\r
\r
- internal void DoRelocs(BinaryWriter reloc) {\r
+ internal void DoRelocs(BinaryWriter reloc) {\r
if (relocTide > 0) {\r
//relocOff = (uint)reloc.Seek(0,SeekOrigin.Current);\r
uint block = (relocs[0]/relocPageSize + 1) * relocPageSize;\r
}\r
DoBlock(reloc,block-relocPageSize,start,(int)relocTide);\r
}\r
- }\r
-\r
- internal void AddReloc(uint offs) {\r
- int pos = 0;\r
- if (relocs == null) {\r
- relocs = new uint[5];\r
- } else {\r
- if (relocTide >= relocs.Length) {\r
- uint[] tmp = relocs;\r
- relocs = new uint[tmp.Length + 5];\r
- for (int i=0; i < relocTide; i++) {\r
- relocs[i] = tmp[i];\r
- }\r
- }\r
- while ((pos < relocTide) && (relocs[pos] < offs)) pos++;\r
- for (int i=pos; i < relocTide; i++) {\r
- relocs[i+1] = relocs[i];\r
- }\r
- }\r
- relocs[pos] = offs;\r
- relocTide++; \r
- }\r
+ }\r
+\r
+ internal void AddReloc(uint offs) {\r
+ int pos = 0;\r
+ if (relocs == null) {\r
+ relocs = new uint[5];\r
+ } else {\r
+ if (relocTide >= relocs.Length) {\r
+ uint[] tmp = relocs;\r
+ relocs = new uint[tmp.Length + 5];\r
+ for (int i=0; i < relocTide; i++) {\r
+ relocs[i] = tmp[i];\r
+ }\r
+ }\r
+ while ((pos < relocTide) && (relocs[pos] < offs)) pos++;\r
+ for (int i=pos; i < relocTide; i++) {\r
+ relocs[i+1] = relocs[i];\r
+ }\r
+ }\r
+ relocs[pos] = offs;\r
+ relocTide++; \r
+ }\r
\r
- internal void WriteHeader(BinaryWriter output, uint relocRVA) {\r
- output.Write(name);\r
- output.Write(tide);\r
- output.Write(rva);\r
- output.Write(size);\r
- output.Write(offset);\r
- output.Write(0);\r
- //output.Write(relocRVA + relocOff);\r
- output.Write(0);\r
+ internal void WriteHeader(BinaryWriter output, uint relocRVA) {\r
+ output.Write(name);\r
+ output.Write(tide);\r
+ output.Write(rva);\r
+ output.Write(size);\r
+ output.Write(offset);\r
+ output.Write(0);\r
+ //output.Write(relocRVA + relocOff);\r
+ output.Write(0);\r
output.Write(0);\r
- //output.Write((ushort)relocTide);\r
- //output.Write((ushort)0);\r
- output.Write(flags);\r
- }\r
+ //output.Write((ushort)relocTide);\r
+ //output.Write((ushort)0);\r
+ output.Write(flags);\r
+ }\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
public abstract class Signature : MetaDataElement \r
{\r
\r
}\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Descriptor for a class defined in System (mscorlib)\r
- /// </summary>\r
+ /// <summary>\r
+ /// Descriptor for a class defined in System (mscorlib)\r
+ /// </summary>\r
internal class SystemClass : ClassRef\r
- {\r
+ {\r
PrimitiveType elemType; \r
\r
- internal SystemClass(PrimitiveType eType, AssemblyRef paren, MetaData md)\r
+ internal SystemClass(PrimitiveType eType, AssemblyRef paren, MetaData md)\r
: base("System",eType.GetName(),md) {\r
elemType = eType;\r
parent = paren;\r
- }\r
+ }\r
\r
internal override sealed MetaDataElement GetTypeSpec(MetaData md) {\r
if (typeSpec == null) typeSpec = (TypeSpec)elemType.GetTypeSpec(md);\r
str.WriteByte(elemType.GetTypeIndex());\r
}\r
\r
- }\r
+ }\r
/**************************************************************************/ \r
- /// <summary>\r
- /// Base class for all IL types\r
- /// </summary>\r
+ /// <summary>\r
+ /// Base class for all IL types\r
+ /// </summary>\r
public abstract class Type : MetaDataElement {\r
protected byte typeIndex;\r
protected TypeSpec typeSpec;\r
projects / mono.git / blobdiff