public static void Link(CLIFile pFile)
{
for (int index = 0; index < pFile.CustomAttributeTable.Length; ++index)
{
pFile.CustomAttributeTable[index].LinkData(pFile);
}
}
public static void Load(CLIFile pFile)
{
for (int index = 0; index < pFile.AssemblyRefOSTable.Length; ++index)
{
pFile.AssemblyRefOSTable[index].LoadData(pFile);
}
}
public void LoadData(CLIFile pFile)
{
int token = 0;
if (pFile.EventTable.Length > HasSemanticsTypeMax16BitRows ||
pFile.PropertyTable.Length > HasSemanticsTypeMax16BitRows)
{
token = pFile.ReadInt32();
}
else
{
token = pFile.ReadUInt16();
}
Type = (HasSemanticsType)(token & HasSemanticsTypeMask);
token = (token >> HasSemanticsTypeBits) - 1;
if (token >= 0)
{
switch (Type)
{
case HasSemanticsType.Event: Event = pFile.EventTable[token]; break;
case HasSemanticsType.Property: Property = pFile.PropertyTable[token]; break;
default: throw new BadImageFormatException("HasSemantics Type");
}
}
}
public void LoadData(CLIFile pFile)
{
int token = 0;
if (pFile.FieldTable.Length > HasFieldMarshalTypeMax16BitRows ||
pFile.ParamTable.Length > HasFieldMarshalTypeMax16BitRows)
{
token = pFile.ReadInt32();
}
else
{
token = pFile.ReadUInt16();
}
Type = (HasFieldMarshalType)(token & HasFieldMarshalTypeMask);
token = (token >> HasFieldMarshalTypeBits) - 1;
if (token >= 0)
{
switch (Type)
{
case HasFieldMarshalType.Field: Field = pFile.FieldTable[token]; break;
case HasFieldMarshalType.Param: Param = pFile.ParamTable[token]; break;
default: throw new BadImageFormatException("HasFieldMarshal Type");
}
}
}
public void LoadData(CLIFile pFile)
{
int token = 0;
if (pFile.MethodDefTable.Length > MethodDefOrRefTypeMax16BitRows ||
pFile.MemberRefTable.Length > MethodDefOrRefTypeMax16BitRows)
{
token = pFile.ReadInt32();
}
else
{
token = pFile.ReadUInt16();
}
Type = (MethodDefOrRefType)(token & MethodDefOrRefTypeMask);
token = (token >> MethodDefOrRefTypeBits) - 1;
if (token >= 0)
{
switch (Type)
{
case MethodDefOrRefType.MethodDef: MethodDef = pFile.MethodDefTable[token]; break;
case MethodDefOrRefType.MemberRef: MemberRef = pFile.MemberRefTable[token]; break;
default: throw new BadImageFormatException("MethodDefOrRef Type");
}
}
}
public void LoadData(CLIFile pFile)
{
int token = 0;
if (pFile.FileTable.Length > ImplementationTypeMax16BitRows ||
pFile.AssemblyRefTable.Length > ImplementationTypeMax16BitRows ||
pFile.ExportedTypeTable.Length > ImplementationTypeMax16BitRows)
{
token = pFile.ReadInt32();
}
else
{
token = pFile.ReadUInt16();
}
Type = (ImplementationType)(token & ImplementationTypeMask);
token = (token >> ImplementationTypeBits) - 1;
if (token >= 0)
{
switch (Type)
{
case ImplementationType.File: File = pFile.FileTable[token]; break;
case ImplementationType.AssemblyRef: AssemblyRef = pFile.AssemblyRefTable[token]; break;
case ImplementationType.ExportedType: ExportedType = pFile.ExportedTypeTable[token]; break;
default: throw new BadImageFormatException("Implementation Type");
}
}
}
public void LoadData(CLIFile pFile)
{
int token = 0;
if (pFile.TypeDefTable.Length > TypeDefRefOrSpecTypeMax16BitRows ||
pFile.TypeRefTable.Length > TypeDefRefOrSpecTypeMax16BitRows ||
pFile.TypeSpecTable.Length > TypeDefRefOrSpecTypeMax16BitRows)
{
token = pFile.ReadInt32();
}
else
{
token = pFile.ReadUInt16();
}
Type = (TypeDefRefOrSpecType)(token & TypeDefRefOrSpecTypeMask);
token = (token >> TypeDefRefOrSpecTypeBits) - 1;
if (token >= 0)
{
switch (Type)
{
case TypeDefRefOrSpecType.TypeDef: TypeDef = pFile.TypeDefTable[token]; break;
case TypeDefRefOrSpecType.TypeRef: TypeRef = pFile.TypeRefTable[token]; break;
case TypeDefRefOrSpecType.TypeSpec: TypeSpec = pFile.TypeSpecTable[token]; break;
default: throw new BadImageFormatException("TypeDefRefOrSpec Type");
}
}
}
public void LoadData(CLIFile pFile)
{
int token = 0;
if (pFile.TypeDefTable.Length > HasDeclSecurityTypeMax16BitRows ||
pFile.MethodDefTable.Length > HasDeclSecurityTypeMax16BitRows ||
pFile.AssemblyTable.Length > HasDeclSecurityTypeMax16BitRows)
{
token = pFile.ReadInt32();
}
else
{
token = pFile.ReadUInt16();
}
Type = (HasDeclSecurityType)(token & HasDeclSecurityTypeMask);
token = (token >> HasDeclSecurityTypeBits) - 1;
if (token >= 0)
{
switch (Type)
{
case HasDeclSecurityType.TypeDef: TypeDef = pFile.TypeDefTable[token]; break;
case HasDeclSecurityType.MethodDef: MethodDef = pFile.MethodDefTable[token]; break;
case HasDeclSecurityType.Assembly: Assembly = pFile.AssemblyTable[token]; break;
default: throw new BadImageFormatException("HasDeclSecurity Type");
}
}
}
public void LoadData(CLIFile pFile)
{
int token = 0;
if (pFile.ModuleTable.Length > ResolutionScopeTypeMax16BitRows ||
pFile.ModuleRefTable.Length > ResolutionScopeTypeMax16BitRows ||
pFile.AssemblyRefTable.Length > ResolutionScopeTypeMax16BitRows ||
pFile.TypeRefTable.Length > ResolutionScopeTypeMax16BitRows)
{
token = pFile.ReadInt32();
}
else
{
token = pFile.ReadUInt16();
}
Type = (ResolutionScopeType)(token & ResolutionScopeTypeMask);
token = (token >> ResolutionScopeTypeBits) - 1;
if (token >= 0)
{
switch (Type)
{
case ResolutionScopeType.Module: Module = pFile.ModuleTable[token]; break;
case ResolutionScopeType.ModuleRef: ModuleRef = pFile.ModuleRefTable[token]; break;
case ResolutionScopeType.AssemblyRef: AssemblyRef = pFile.AssemblyRefTable[token]; break;
case ResolutionScopeType.TypeRef: TypeRef = pFile.TypeRefTable[token]; break;
default: throw new BadImageFormatException("ResolutionScope Type");
}
}
}
private void LinkData(CLIFile pFile)
{
int cursor = 0;
if (Signature[0] == 0x06) ExpandedFieldSignature = new FieldSig(pFile, Signature, ref cursor);
else if (Signature[0] == 0x07) ExpandedLocalVarSignature = new LocalVarSig(pFile, Signature, ref cursor);
else ExpandedMethodSignature = new MethodSig(pFile, Signature, ref cursor);
}
private void LoadData(CLIFile pFile)
{
Number = pFile.ReadUInt16();
Flags = (GenericParamAttributes)pFile.ReadUInt16();
Owner.LoadData(pFile);
Name = pFile.ReadStringHeap(pFile.ReadHeapIndex(HeapOffsetSizes.Strings32Bit));
}
public static void Link(CLIFile pFile)
{
for (int index = 0; index < pFile.AssemblyProcessorTable.Length; ++index)
{
pFile.AssemblyProcessorTable[index].LinkData(pFile);
}
}
public static void Link(CLIFile pFile)
{
for (int index = 0; index < pFile.DeclSecurityTable.Length; ++index)
{
pFile.DeclSecurityTable[index].LinkData(pFile);
}
}
private void LoadData(CLIFile pFile)
{
Number = pFile.ReadUInt16();
Flags = pFile.ReadUInt16();
Owner.LoadData(pFile);
Name = pFile.ReadStringHeap(pFile.ReadHeapIndex(CLIHeapOffsetSize.Strings32Bit));
}
public SigRetType(CLIFile pCLIFile, byte[] pSignature, ref int pCursor)
{
CLIFile = pCLIFile;
while (pSignature[pCursor] == (byte)SigElementType.CustomModifier_Required ||
pSignature[pCursor] == (byte)SigElementType.CustomModifier_Optional)
{
Mods.Add(new SigCustomMod(CLIFile, pSignature, ref pCursor));
}
if (pSignature[pCursor] == (byte)SigElementType.TypedByReference)
{
TypedByRef = true;
++pCursor;
return;
}
if (pSignature[pCursor] == (byte)SigElementType.Void)
{
Void = true;
++pCursor;
return;
}
if (pSignature[pCursor] == (byte)SigElementType.ByReference)
{
ByRef = true;
++pCursor;
}
Type = new SigType(CLIFile, pSignature, ref pCursor);
}
private void LoadData(CLIFile pFile)
{
Offset = pFile.ReadUInt32();
Flags = pFile.ReadUInt32();
Name = pFile.ReadStringHeap(pFile.ReadHeapIndex(CLIHeapOffsetSize.Strings32Bit));
Implementation.LoadData(pFile);
}
public SigLocalVar(CLIFile pCLIFile, byte[] pSignature, ref int pCursor)
{
CLIFile = pCLIFile;
if (pSignature[pCursor] == (byte)SigElementType.TypedByReference)
{
TypedByRef = true;
++pCursor;
}
else
{
while (pSignature[pCursor] == (byte)SigElementType.CustomModifier_Required ||
pSignature[pCursor] == (byte)SigElementType.CustomModifier_Optional)
{
Mods.Add(new SigCustomMod(CLIFile, pSignature, ref pCursor));
}
if (pSignature[pCursor] == (byte)SigElementType.Pinned)
{
IsPinned = true;
++pCursor;
}
if (pSignature[pCursor] == (byte)SigElementType.ByReference)
{
ByRef = true;
++pCursor;
}
Type = new SigType(CLIFile, pSignature, ref pCursor);
}
}
public static void Load(CLIFile pFile)
{
for (int index = 0; index < pFile.GenericParamTable.Length; ++index)
{
pFile.GenericParamTable[index].LoadData(pFile);
}
}
public SigLocalVar(CLIFile pCLIFile, byte[] pSignature, ref int pCursor)
{
CLIFile = pCLIFile;
if (pSignature[pCursor] == (byte)SigElementType.TypedByReference)
{
TypedByRef = true;
++pCursor;
}
else
{
while (pSignature[pCursor] == (byte)SigElementType.CustomModifier_Required ||
pSignature[pCursor] == (byte)SigElementType.CustomModifier_Optional)
{
Mods.Add(new SigCustomMod(CLIFile, pSignature, ref pCursor));
}
if (pSignature[pCursor] == (byte)SigElementType.Pinned)
{
IsPinned = true;
++pCursor;
}
if (pSignature[pCursor] == (byte)SigElementType.ByReference)
{
ByRef = true;
++pCursor;
}
Type = new SigType(CLIFile, pSignature, ref pCursor);
}
}
private void LoadData(CLIFile pFile)
{
Number = pFile.ReadUInt16();
Flags = pFile.ReadUInt16();
Owner.LoadData(pFile);
Name = pFile.ReadStringHeap(pFile.ReadHeapIndex(CLIHeapOffsetSize.Strings32Bit));
}
public static void Link(CLIFile pFile)
{
for (int index = 0; index < pFile.FieldMarshalTable.Length; ++index)
{
pFile.FieldMarshalTable[index].LinkData(pFile);
}
}
private void LoadData(CLIFile pFile)
{
Offset = pFile.ReadUInt32();
Flags = pFile.ReadUInt32();
Name = pFile.ReadStringHeap(pFile.ReadHeapIndex(CLIHeapOffsetSize.Strings32Bit));
Implementation.LoadData(pFile);
}
public static void Link(CLIFile pFile)
{
for (int index = 0; index < pFile.TypeDefTable.Length; ++index)
{
pFile.TypeDefTable[index].LinkData(pFile);
}
}
public static void Load(CLIFile pFile)
{
for (int index = 0; index < pFile.ModuleTable.Length; ++index)
{
pFile.ModuleTable[index].LoadData(pFile);
}
}
private void LoadData(CLIFile pFile)
{
Offset = pFile.ReadUInt32();
Flags = (ManifestResourceAttributes)pFile.ReadUInt32();
Name = pFile.ReadStringHeap(pFile.ReadHeapIndex(HeapOffsetSizes.Strings32Bit));
Implementation.LoadData(pFile);
}
public void TrackCallsTest()
{
MethodTableCursor cur = CLIFile.FindMethod(typeof(GenericsUnitTest).GetMethod("ExpressionInput"));
CLIFileRW.MethodBody cb = cur.MethodBody;
LocalsVarSig locals = cb.LocalsSignature;
CLIType[] vars = locals.GetVariables().ToArray <CLIType>();
CLIType[] args = cur.GetMethodSignature().GetParameters(cur.FindCLIType()).ToArray <CLIType>();
ILCursor ilc = cb.ILInstructions;
ilc.TrackStack(args, vars, cb.MaxStack);
while (ilc.Next())
{
ILInstruction instr = ilc.Instr;
object o = instr.ResolveParameter(f);
if (ilc.IsCall)
{
Target[] cargs = ilc.CallLoadArguments();
MethodDesc m = (MethodDesc)o;
System.Diagnostics.Debug.WriteLine(string.Format("{0} to {1} at offset {2:X4}", ilc.Instr.op, m.Name, ilc.Position));
for (int i = 0; i < cargs.Length; i++)
{
System.Diagnostics.Debug.WriteLine(string.Format("\tPar {0} at offset {1:X4}", i, cargs[i].Position));
}
}
}
}
public MscorlibRegressionTest()
{
Type objectType = typeof(Object);
asm = objectType.Assembly;
reader = CLIFile.Open(asm.Location);
}
public SigCustomMod(CLIFile pCLIFile, byte[] pSignature, ref int pCursor)
{
CLIFile = pCLIFile;
Optional = pSignature[pCursor++] == (byte)SigElementType.CustomModifier_Optional;
TypeDefOrRefOrSpecToken = CLIFile.ReadCompressedUnsigned(pSignature, ref pCursor);
}
public MethodSig(CLIFile pCLIFile, byte[] pSignature, ref int pCursor)
{
CLIFile = pCLIFile;
byte callingConvention = pSignature[pCursor++];
HasThis = (callingConvention & CallingConvention.HasThis) != 0;
ExplicitThis = (callingConvention & CallingConvention.ExplicitThis) != 0;
if ((callingConvention & CallingConvention.HasThis) != 0) callingConvention ^= CallingConvention.HasThis;
if ((callingConvention & CallingConvention.ExplicitThis) != 0) callingConvention ^= CallingConvention.ExplicitThis;
Default = callingConvention == CallingConvention.Default;
CCall = callingConvention == CallingConvention.CCall;
STDCall = callingConvention == CallingConvention.STDCall;
ThisCall = callingConvention == CallingConvention.ThisCall;
FastCall = callingConvention == CallingConvention.FastCall;
VarArg = callingConvention == CallingConvention.VarArgs;
Generic = callingConvention == CallingConvention.Generic;
if (Generic) GenParamCount = CLIFile.ReadCompressedUnsigned(pSignature, ref pCursor);
uint paramCount = CLIFile.ReadCompressedUnsigned(pSignature, ref pCursor);
Params = new List<SigParam>((int)paramCount);
RetType = new SigRetType(CLIFile, pSignature, ref pCursor);
if (paramCount > 0)
{
for (uint paramIndex = 0; paramIndex < paramCount; ++paramIndex)
{
if (pSignature[pCursor] == (byte)SigElementType.Sentinel)
{
HasSentinel = true;
SentinelIndex = paramIndex;
++pCursor;
}
Params.Add(new SigParam(CLIFile, pSignature, ref pCursor));
}
}
}
public static void Link(CLIFile pFile)
{
for (int index = 0; index < pFile.ManifestResourceTable.Length; ++index)
{
pFile.ManifestResourceTable[index].LinkData(pFile);
}
}
public static void Link(CLIFile pFile)
{
for (int index = 0; index < pFile.GenericParamConstraintTable.Length; ++index)
{
pFile.GenericParamConstraintTable[index].LinkData(pFile);
}
}
private void LoadData(CLIFile pFile)
{
Type = (SigElementType)pFile.ReadByte();
pFile.ReadByte();
Parent.LoadData(pFile);
Value = pFile.ReadBlobHeap(pFile.ReadHeapIndex(HeapOffsetSizes.Blob32Bit));
}
/// <summary>
/// Return the Reflection type associated with the type subtree.
/// </summary>
/// <param name="f">Reader to be used for resolving tokens.</param>
/// <param name="typepars">
/// Generic instantiation of enclosing generic type arguments if any
/// (null otherwise)
/// </param>
/// <param name="methodpars">
/// Generic instantiation of enclosing generic method arguments if any
/// (null otherwise)
/// </param>
/// <returns>The Reflection type associated with the type subtree.</returns>
public override Type GetReflectionType(CLIFile f, Type[] typepars, Type[] methodpars)
{
if (typepars == null)
{
throw new Exception("Type parameters of type instantiation are required to resolve type!");
}
return(typepars[num]);
}
private void LoadData(CLIFile pFile)
{
Offset = pFile.ReadUInt32();
int fieldIndex = 0;
if (pFile.FieldTable.Length >= 0xFFFF) fieldIndex = pFile.ReadInt32() - 1;
else fieldIndex = pFile.ReadUInt16() - 1;
if (fieldIndex >= 0) Field = pFile.FieldTable[fieldIndex];
}
private void LoadData(CLIFile pFile)
{
Generation = pFile.ReadUInt16();
Name = pFile.ReadStringHeap(pFile.ReadHeapIndex(CLIHeapOffsetSize.Strings32Bit));
Mvid = pFile.ReadGUIDHeap(pFile.ReadHeapIndex(CLIHeapOffsetSize.GUID32Bit));
EncId = pFile.ReadGUIDHeap(pFile.ReadHeapIndex(CLIHeapOffsetSize.GUID32Bit));
EncBaseId = pFile.ReadGUIDHeap(pFile.ReadHeapIndex(CLIHeapOffsetSize.GUID32Bit));
}
private void LoadData(CLIFile pFile)
{
int typeDefIndex = 0;
if (pFile.TypeDefTable.Length >= 0xFFFF) typeDefIndex = pFile.ReadInt32() - 1;
else typeDefIndex = pFile.ReadUInt16() - 1;
if (typeDefIndex >= 0) Class = pFile.TypeDefTable[typeDefIndex];
Interface.LoadData(pFile);
}
private void LoadData(CLIFile pFile)
{
Generation = pFile.ReadUInt16();
Name = pFile.ReadStringHeap(pFile.ReadHeapIndex(CLIHeapOffsetSize.Strings32Bit));
Mvid = pFile.ReadGUIDHeap(pFile.ReadHeapIndex(CLIHeapOffsetSize.GUID32Bit));
EncId = pFile.ReadGUIDHeap(pFile.ReadHeapIndex(CLIHeapOffsetSize.GUID32Bit));
EncBaseId = pFile.ReadGUIDHeap(pFile.ReadHeapIndex(CLIHeapOffsetSize.GUID32Bit));
}
private void LoadData(CLIFile pFile)
{
Processor = pFile.ReadUInt32();
int assemblyRefIndex = 0;
if (pFile.AssemblyRefTable.Length >= 0xFFFF) assemblyRefIndex = pFile.ReadInt32() - 1;
else assemblyRefIndex = pFile.ReadUInt16() - 1;
if (assemblyRefIndex >= 0) AssemblyRef = pFile.AssemblyRefTable[assemblyRefIndex];
}
private void LoadData(CLIFile pFile)
{
int genericParamIndex = 0;
if (pFile.GenericParamTable.Length >= 0xFFFF) genericParamIndex = pFile.ReadInt32() - 1;
else genericParamIndex = pFile.ReadUInt16() - 1;
if (genericParamIndex >= 0) Owner = pFile.GenericParamTable[genericParamIndex];
Constraint.LoadData(pFile);
}
public LocalVarSig(CLIFile pCLIFile, byte[] pSignature, ref int pCursor)
{
CLIFile = pCLIFile;
++pCursor;
uint localVarCount = CLIFile.ReadCompressedUnsigned(pSignature, ref pCursor);
LocalVars = new List<SigLocalVar>((int)localVarCount);
for (uint localVarIndex = 0; localVarIndex < localVarCount; ++localVarIndex) LocalVars.Add(new SigLocalVar(CLIFile, pSignature, ref pCursor));
}
private void LinkData(CLIFile pFile)
{
int paramListCount = pFile.ParamTable.Length - ParamListIndex;
if (TableIndex < (pFile.MethodDefTable.Length - 1)) paramListCount = pFile.MethodDefTable[TableIndex + 1].ParamListIndex - ParamListIndex;
for (int index = 0; index < paramListCount; ++index) { ParamList.Add(pFile.ParamTable[ParamListIndex + index]); pFile.ParamTable[ParamListIndex + index].ParentMethodDef = this; }
int cursor = 0;
ExpandedSignature = new MethodSig(pFile, Signature, ref cursor);
}
public MethodSpecSig(CLIFile pCLIFile, byte[] pSignature, ref int pCursor)
{
CLIFile = pCLIFile;
++pCursor;
uint genArgsCount = CLIFile.ReadCompressedUnsigned(pSignature, ref pCursor);
GenArgs = new List<SigType>((int)genArgsCount);
for (uint genArgsIndex = 0; genArgsIndex < genArgsCount; ++genArgsIndex) GenArgs.Add(new SigType(CLIFile, pSignature, ref pCursor));
}
private void LoadData(CLIFile pFile)
{
Semantics = pFile.ReadUInt16();
int methodDefIndex = 0;
if (pFile.MethodDefTable.Length >= 0xFFFF) methodDefIndex = pFile.ReadInt32() - 1;
else methodDefIndex = pFile.ReadUInt16() - 1;
if (methodDefIndex >= 0) Method = pFile.MethodDefTable[methodDefIndex];
Association.LoadData(pFile);
}
private void LoadData(CLIFile pFile)
{
PackingSize = pFile.ReadUInt16();
ClassSize = pFile.ReadUInt32();
int typeDefIndex = 0;
if (pFile.TypeDefTable.Length >= 0xFFFF) typeDefIndex = pFile.ReadInt32() - 1;
else typeDefIndex = pFile.ReadUInt16() - 1;
if (typeDefIndex >= 0) Parent = pFile.TypeDefTable[typeDefIndex];
}
private void LoadData(CLIFile pFile)
{
int typeDefIndex = 0;
if (pFile.TypeDefTable.Length >= 0xFFFF) typeDefIndex = pFile.ReadInt32() - 1;
else typeDefIndex = pFile.ReadUInt16() - 1;
if (typeDefIndex >= 0) Class = pFile.TypeDefTable[typeDefIndex];
MethodBody.LoadData(pFile);
MethodDeclaration.LoadData(pFile);
}
public static void Initialize(CLIFile pFile)
{
if ((pFile.CLIMetadataTables.PresentTables & (1ul << MetadataTables.PropertyMap)) != 0)
{
pFile.PropertyMapTable = new PropertyMapData[pFile.ReadInt32()];
for (int index = 0; index < pFile.PropertyMapTable.Length; ++index) pFile.PropertyMapTable[index] = new PropertyMapData() { CLIFile = pFile, TableIndex = index };
}
else pFile.PropertyMapTable = new PropertyMapData[0];
}
public static void Initialize(CLIFile pFile)
{
if ((pFile.CLIMetadataTablesHeader.PresentTables & (1ul << CLIMetadataTables.GenericParam)) != 0)
{
pFile.GenericParamTable = new GenericParamData[pFile.ReadInt32()];
for (int index = 0; index < pFile.GenericParamTable.Length; ++index) pFile.GenericParamTable[index] = new GenericParamData() { CLIFile = pFile, TableIndex = index };
}
else pFile.GenericParamTable = new GenericParamData[0];
}
private void LoadData(CLIFile pFile)
{
int typeDefIndex = 0;
if (pFile.TypeDefTable.Length >= 0xFFFF) typeDefIndex = pFile.ReadInt32() - 1;
else typeDefIndex = pFile.ReadUInt16() - 1;
if (typeDefIndex >= 0) Parent = pFile.TypeDefTable[typeDefIndex];
if (pFile.PropertyTable.Length >= 0xFFFF) PropertyListIndex = pFile.ReadInt32() - 1;
else PropertyListIndex = pFile.ReadUInt16() - 1;
}
public static void Initialize(CLIFile pFile)
{
if ((pFile.CLIMetadataTablesHeader.PresentTables & (1ul << CLIMetadataTables.ManifestResource)) != 0)
{
pFile.ManifestResourceTable = new ManifestResourceData[pFile.ReadInt32()];
for (int index = 0; index < pFile.ManifestResourceTable.Length; ++index) pFile.ManifestResourceTable[index] = new ManifestResourceData() { CLIFile = pFile, TableIndex = index };
}
else pFile.ManifestResourceTable = new ManifestResourceData[0];
}
private void LinkData(CLIFile pFile)
{
int fieldListCount = pFile.FieldTable.Length - FieldListIndex;
if (TableIndex < (pFile.TypeDefTable.Length - 1)) fieldListCount = pFile.TypeDefTable[TableIndex + 1].FieldListIndex - FieldListIndex;
for (int index = 0; index < fieldListCount; ++index) { FieldList.Add(pFile.FieldTable[FieldListIndex + index]); pFile.FieldTable[FieldListIndex + index].ParentTypeDef = this; }
int methodListCount = pFile.MethodDefTable.Length - MethodListIndex;
if (TableIndex < (pFile.TypeDefTable.Length - 1)) methodListCount = pFile.TypeDefTable[TableIndex + 1].MethodListIndex - MethodListIndex;
for (int index = 0; index < methodListCount; ++index) { MethodList.Add(pFile.MethodDefTable[MethodListIndex + index]); pFile.MethodDefTable[MethodListIndex + index].ParentTypeDef = this; }
}
public static void Initialize(CLIFile pFile)
{
if ((pFile.CLIMetadataTablesHeader.PresentTables & (1ul << CLIMetadataTables.File)) != 0)
{
pFile.FileTable = new FileData[pFile.ReadInt32()];
for (int index = 0; index < pFile.FileTable.Length; ++index) pFile.FileTable[index] = new FileData() { CLIFile = pFile, TableIndex = index };
}
else pFile.FileTable = new FileData[0];
}
public static void Initialize(CLIFile pFile)
{
if ((pFile.CLIMetadataTablesHeader.PresentTables & (1ul << CLIMetadataTables.AssemblyProcessor)) != 0)
{
pFile.AssemblyProcessorTable = new AssemblyProcessorData[pFile.ReadInt32()];
for (int index = 0; index < pFile.AssemblyProcessorTable.Length; ++index) pFile.AssemblyProcessorTable[index] = new AssemblyProcessorData() { CLIFile = pFile, TableIndex = index };
}
else pFile.AssemblyProcessorTable = new AssemblyProcessorData[0];
}
private void LoadData(CLIFile pFile)
{
InitialValueOffset = pFile.ReadUInt32();
CLIFile.SectionHeader sectionHeader = pFile.GetSection(InitialValueOffset);
InitialValueOffset = sectionHeader.PointerToRawData + (InitialValueOffset - sectionHeader.VirtualAddress);
int fieldIndex = 0;
if (pFile.FieldTable.Length >= 0xFFFF) fieldIndex = pFile.ReadInt32() - 1;
else fieldIndex = pFile.ReadUInt16() - 1;
if (fieldIndex >= 0) Field = pFile.FieldTable[fieldIndex];
}
public static tAsyncCall *EnsureAssemblyLoaded(tJITCallNative *pCallNative, byte *pThis_, byte *pParams, byte *pReturnValue)
{
byte *assemblyName = stackalloc byte[256];
DotNetStringToCString(assemblyName, 256, ((tSystemString **)pParams)[0]);
CLIFile.GetMetaDataForAssembly(assemblyName);
*(/*HEAP_PTR*/ byte **)pReturnValue = null;
return(null);
}
private void LoadData(CLIFile pFile)
{
OSPlatformId = pFile.ReadUInt32();
OSMajorVersion = pFile.ReadUInt32();
OSMinorVersion = pFile.ReadUInt32();
int assemblyRefIndex = 0;
if (pFile.AssemblyRefTable.Length >= 0xFFFF) assemblyRefIndex = pFile.ReadInt32() - 1;
else assemblyRefIndex = pFile.ReadUInt16() - 1;
if (assemblyRefIndex >= 0) AssemblyRef = pFile.AssemblyRefTable[assemblyRefIndex];
}
public IRAssembly LoadEntryAssembly(CLIFile pFile)
{
IRAssembly assembly = CreateAssembly(pFile);
Assemblies.ForEach(a => a.LoadStage1());
Assemblies.ForEach(a => a.LoadStage2());
Assemblies.ForEach(a => a.LoadStage3());
Assemblies.ForEach(a => a.LoadStage4());
return(assembly);
}
private void LoadData(CLIFile pFile)
{
MappingFlags = (PInvokeAttributes)pFile.ReadUInt16();
MemberForwarded.LoadData(pFile);
ImportName = pFile.ReadStringHeap(pFile.ReadHeapIndex(HeapOffsetSizes.Strings32Bit));
int moduleRefIndex = 0;
if (pFile.ModuleRefTable.Length >= 0xFFFF) moduleRefIndex = pFile.ReadInt32() - 1;
else moduleRefIndex = pFile.ReadUInt16() - 1;
if (moduleRefIndex >= 0) ImportScope = pFile.ModuleRefTable[moduleRefIndex];
}
public void StandAloneSigTest()
{
CLIFile f = CLIFile.Open(typeof(object).Assembly.Location);
Table t = f[TableNames.StandAloneSig];
StandAloneSigTableCursor cur = t.GetCursor() as StandAloneSigTableCursor;
while (cur.Next())
{
Assert.IsTrue(cur.Signature < f.Blob.Size, "Wrong index into the blob heap!");
}
}
/// <summary>
/// Return the Reflection type associated with the type subtree.
/// </summary>
/// <param name="f">Reader to be used for resolving tokens.</param>
/// <param name="typepars">
/// Generic instantiation of enclosing generic type arguments if any
/// (null otherwise)
/// </param>
/// <param name="methodpars">
/// Generic instantiation of enclosing generic method arguments if any
/// (null otherwise)
/// </param>
/// <returns>The Reflection type associated with the type subtree.</returns>
public override Type GetReflectionType(CLIFile f, Type[] typepars, Type[] methodpars)
{
Type ret = f.Assembly.ManifestModule.ResolveType((((int)Type) << 24) | Row);
if (args != null)
{
Type[] ts = Array.ConvertAll <CLIType, Type>(args, delegate(CLIType tt) { return(tt.GetReflectionType(typepars, methodpars)); });
ret = ret.MakeGenericType(ts);
}
return(ret);
}
public FieldSig(CLIFile pCLIFile, byte[] pSignature, ref int pCursor)
{
CLIFile = pCLIFile;
++pCursor;
while (pSignature[pCursor] == (byte)SigElementType.CustomModifier_Required ||
pSignature[pCursor] == (byte)SigElementType.CustomModifier_Optional)
{
Mods.Add(new SigCustomMod(CLIFile, pSignature, ref pCursor));
}
Type = new SigType(CLIFile, pSignature, ref pCursor);
}
