private void ReadILCode()
{
NuGenCodeLine start = new NuGenCodeLine();
start.Text = "{";
CodeLines.Add(start);
if (EntryPoint)
{
CodeLines.Add(new NuGenCodeLine(1, ".entrypoint"));
}
if (Overrides != 0)
{
NuGenTokenBase overridenMember = BaseTypeDefinition.ModuleScope.Assembly.AllTokens[Overrides];
Type overridenMemberType = overridenMember.GetType();
string memberName;
if (GenericParameters != null && overridenMember is NuGenIHasSignature)
{
NuGenIHasSignature hasSignature = (NuGenIHasSignature)overridenMember;
hasSignature.SignatureReader.SetGenericParametersOfMethod(GenericParameters);
}
if (overridenMemberType == typeof(NuGenMemberReference))
{
NuGenMemberReference memberReference = (NuGenMemberReference)overridenMember;
memberName = memberReference.Text;
}
else if (overridenMemberType == typeof(NuGenMethodDefinition))
{
NuGenMethodDefinition methodDefinition = (NuGenMethodDefinition)overridenMember;
memberName = string.Format("{0}::{1}", methodDefinition.BaseTypeDefinition.FullName, methodDefinition.Name);
}
else
{
throw new NotImplementedException(string.Format("Unhandled overriden member type ('{0}').", overridenMemberType.FullName));
}
CodeLines.Add(new NuGenCodeLine(1, ".override method " + memberName));
}
if (CustomAttributes != null)
{
NuGenAssembly assembly = BaseTypeDefinition.ModuleScope.Assembly;
foreach (NuGenCustomAttribute customAttribute in CustomAttributes)
{
CodeLines.Add(new NuGenCodeLine(1, customAttribute.Name));
}
}
int codeSizePosition = 2;
if (Parameters != null)
{
NuGenAssembly assembly = BaseTypeDefinition.ModuleScope.Assembly;
try
{
assembly.OpenMetadataInterfaces();
foreach (NuGenParameter parameter in Parameters)
{
parameter.LazyInitialize(BaseTypeDefinition.ModuleScope.Assembly.AllTokens);
bool hasDefault = ((parameter.AttributeFlags & CorParamAttr.pdHasDefault) == CorParamAttr.pdHasDefault);
if (hasDefault)
{
NuGenCodeLine defaultParameter = new NuGenCodeLine();
defaultParameter.Indentation = 1;
defaultParameter.Text = parameter.DefaultValueAsString;
CodeLines.Add(defaultParameter);
codeSizePosition++;
}
if (parameter.CustomAttributes != null)
{
if (!hasDefault)
{
NuGenCodeLine parameterLine = new NuGenCodeLine(1, string.Format(".param [{0}]", parameter.OrdinalIndex));
CodeLines.Add(parameterLine);
codeSizePosition++;
}
foreach (NuGenCustomAttribute customAttribute in parameter.CustomAttributes)
{
NuGenCodeLine customAttributeLine = new NuGenCodeLine(1, customAttribute.Name);
CodeLines.Add(customAttributeLine);
codeSizePosition++;
}
}
}
}
finally
{
assembly.CloseMetadataInterfaces();
}
}
if (PermissionSets != null)
{
foreach (NuGenPermissionSet permissionSet in PermissionSets)
{
NuGenCodeLine permissionSetLine = new NuGenCodeLine(1, permissionSet.Name);
CodeLines.Add(permissionSetLine);
codeSizePosition++;
}
}
if (((Rva > 0) || BaseTypeDefinition.ModuleScope.Assembly.IsInMemory) && ((ImplementationFlags & CorMethodImpl.miCodeTypeMask) != CorMethodImpl.miNative))
{
NuGenAssembly assembly = BaseTypeDefinition.ModuleScope.Assembly;
BinaryReader assemblyReader = null;
if (assembly.IsInMemory)
{
NuGenInMemoryMethodStream methodStream = new NuGenInMemoryMethodStream(assembly.DebuggedProcess, FindMethodHeader());
assemblyReader = new BinaryReader(methodStream);
}
else
{
assembly.OpenAssemblyReader();
assemblyReader = assembly.AssemblyReader;
assemblyReader.BaseStream.Position = assembly.GetMethodAddress(Rva);
}
byte methodHeader = assemblyReader.ReadByte();
int methodLength = 0;
bool moreSects = false;
if ((methodHeader & (byte)ILMethodHeader.CorILMethod_FatFormat) == (byte)ILMethodHeader.CorILMethod_FatFormat)
{
byte methodHeaderByte2 = assemblyReader.ReadByte();
moreSects = ((methodHeader & (byte)CorILMethodFlags.CorILMethod_MoreSects) == (byte)CorILMethodFlags.CorILMethod_MoreSects);
byte sizeOfHeader = Convert.ToByte((methodHeaderByte2 >> 4) * 4);
ushort maxStack = assemblyReader.ReadUInt16();
methodLength = assemblyReader.ReadInt32();
uint localVarSigToken = assemblyReader.ReadUInt32();
NuGenCodeLine maxStackLine = new NuGenCodeLine(1, string.Format(".maxstack {0}", maxStack));
CodeLines.Add(maxStackLine);
if (localVarSigToken != 0 && BaseTypeDefinition.ModuleScope.Assembly.StandAloneSignatures != null && BaseTypeDefinition.ModuleScope.Assembly.StandAloneSignatures.ContainsKey(localVarSigToken))
{
string initLocals = string.Empty;
if ((methodHeader & (byte)CorILMethodFlags.CorILMethod_InitLocals) == (byte)CorILMethodFlags.CorILMethod_InitLocals)
{
initLocals = "init ";
}
NuGenStandAloneSignature standAloneSignature = BaseTypeDefinition.ModuleScope.Assembly.StandAloneSignatures[localVarSigToken];
if (GenericParameters != null && standAloneSignature.SignatureReader.HasGenericMethodParameter)
{
standAloneSignature.SignatureReader.SetGenericParametersOfMethod(GenericParameters);
standAloneSignature.LazyInitialize(BaseTypeDefinition.ModuleScope.Assembly.AllTokens);
}
NuGenCodeLine variablesLine = new NuGenCodeLine(1, string.Format(".locals {0}{1}", initLocals, standAloneSignature.Text));
CodeLines.Add(variablesLine);
}
}
else if ((methodHeader & (byte)ILMethodHeader.CorILMethod_TinyFormat) == (byte)ILMethodHeader.CorILMethod_TinyFormat)
{
methodLength = methodHeader >> 2;
}
NuGenCodeLine codeSize = new NuGenCodeLine(1, string.Format("// Code size {0} (0x{1:x})", methodLength, methodLength));
if (CustomAttributes != null)
{
codeSizePosition++;
}
if (EntryPoint)
{
codeSizePosition++;
}
if (Overrides != 0)
{
codeSizePosition++;
}
CodeLines.Insert(codeSizePosition, codeSize);
if ((ImplementationFlags & CorMethodImpl.miNative) != CorMethodImpl.miNative)
{
byte[] methodCode = new byte[methodLength];
assemblyReader.Read(methodCode, 0, methodLength);
int methodCodeIndex = 0;
while (methodCodeIndex < methodCode.Length)
{
int offset = methodCodeIndex;
short opCodeValue = methodCode[methodCodeIndex++];
if (opCodeValue == 0xFE)
{
opCodeValue = (short)(opCodeValue * 0x100 + methodCode[methodCodeIndex++]);
}
if (NuGenOpCodeGroups.OpCodesByValue.ContainsKey(opCodeValue))
{
OpCode opCode = NuGenOpCodeGroups.OpCodesByValue[opCodeValue];
OpCodeGroup opCodeGroup = NuGenOpCodeGroups.GetGroupOfOpCode(opCode);
int parameterSize = 0;
switch (opCodeGroup)
{
case OpCodeGroup.ByteArgumentParameter:
case OpCodeGroup.ByteParameter:
case OpCodeGroup.ByteVariableParameter:
case OpCodeGroup.SbyteLocationParameter:
case OpCodeGroup.SbyteParameter:
parameterSize = 1;
break;
case OpCodeGroup.UshortArgumentParameter:
case OpCodeGroup.UshortParameter:
case OpCodeGroup.UshortVariableParameter:
parameterSize = 2;
break;
case OpCodeGroup.FloatParameter:
case OpCodeGroup.FieldParameter:
case OpCodeGroup.IntLocationParameter:
case OpCodeGroup.IntParameter:
case OpCodeGroup.MethodParameter:
case OpCodeGroup.StringParameter:
case OpCodeGroup.TypeParameter:
case OpCodeGroup.Calli:
case OpCodeGroup.Ldtoken:
case OpCodeGroup.Switch:
parameterSize = 4;
break;
case OpCodeGroup.DoubleParameter:
case OpCodeGroup.LongParameter:
parameterSize = 8;
break;
}
ulong parameter = 0;
if (parameterSize > 0)
{
parameter = NuGenHelperFunctions.GetILCodeParameter(methodCode, methodCodeIndex, parameterSize);
}
NuGenBaseILCode code = null;
switch (opCodeGroup)
{
case OpCodeGroup.Parameterless:
code = new NuGenBaseILCode();
break;
case OpCodeGroup.FieldParameter:
NuGenFieldILCode fieldILCode = new NuGenFieldILCode();
code = fieldILCode;
fieldILCode.Parameter = Convert.ToUInt32(parameter);
fieldILCode.DecodedParameter = assembly.AllTokens[fieldILCode.Parameter];
if (GenericParameters != null)
{
fieldILCode.SetGenericsMethodParameters(assembly.AllTokens, GenericParameters);
}
break;
case OpCodeGroup.MethodParameter:
NuGenMethodILCode methodILCode = new NuGenMethodILCode();
code = methodILCode;
methodILCode.Parameter = Convert.ToUInt32(parameter);
methodILCode.DecodedParameter = assembly.AllTokens[methodILCode.Parameter];
if (GenericParameters != null)
{
methodILCode.SetGenericsMethodParameters(assembly.AllTokens, GenericParameters);
}
break;
case OpCodeGroup.StringParameter:
NuGenStringILCode stringILCode = new NuGenStringILCode();
code = stringILCode;
stringILCode.Parameter = Convert.ToUInt32(parameter);
stringILCode.DecodedParameter = assembly.UserStrings[stringILCode.Parameter];
break;
case OpCodeGroup.TypeParameter:
NuGenTypeILCode typeILCode = new NuGenTypeILCode();
code = typeILCode;
typeILCode.Parameter = Convert.ToUInt32(parameter);
typeILCode.DecodedParameter = assembly.AllTokens[typeILCode.Parameter];
if (GenericParameters != null)
{
typeILCode.SetGenericsMethodParameters(assembly.AllTokens, GenericParameters);
}
break;
case OpCodeGroup.IntLocationParameter:
LocationILCode<int> intLocationILCode = new LocationILCode<int>();
code = intLocationILCode;
intLocationILCode.Parameter = (int)parameter;
intLocationILCode.DecodedParameter = intLocationILCode.Parameter;
break;
case OpCodeGroup.SbyteLocationParameter:
LocationILCode<sbyte> sbyteLocationILCode = new LocationILCode<sbyte>();
code = sbyteLocationILCode;
sbyteLocationILCode.Parameter = (sbyte)parameter;
sbyteLocationILCode.DecodedParameter = sbyteLocationILCode.Parameter;
break;
case OpCodeGroup.ByteParameter:
NumberILCode<byte> byteNumberILCode = new NumberILCode<byte>();
code = byteNumberILCode;
byteNumberILCode.Parameter = (byte)parameter;
byteNumberILCode.DecodedParameter = byteNumberILCode.Parameter;
break;
case OpCodeGroup.UshortParameter:
NumberILCode<ushort> ushortNumberILCode = new NumberILCode<ushort>();
code = ushortNumberILCode;
ushortNumberILCode.Parameter = (ushort)parameter;
ushortNumberILCode.DecodedParameter = ushortNumberILCode.Parameter;
break;
case OpCodeGroup.SbyteParameter:
NumberILCode<sbyte> sbyteNumberILCode = new NumberILCode<sbyte>();
code = sbyteNumberILCode;
sbyteNumberILCode.Parameter = (sbyte)parameter;
sbyteNumberILCode.DecodedParameter = sbyteNumberILCode.Parameter;
break;
case OpCodeGroup.IntParameter:
NumberILCode<int> intNumberILCode = new NumberILCode<int>();
code = intNumberILCode;
intNumberILCode.Parameter = (int)parameter;
intNumberILCode.DecodedParameter = intNumberILCode.Parameter;
break;
case OpCodeGroup.LongParameter:
NumberILCode<long> longNumberILCode = new NumberILCode<long>();
code = longNumberILCode;
longNumberILCode.Parameter = (long)parameter;
longNumberILCode.DecodedParameter = longNumberILCode.Parameter;
break;
case OpCodeGroup.FloatParameter:
NumberILCode<float> floatNumberILCode = new NumberILCode<float>();
code = floatNumberILCode;
floatNumberILCode.Parameter = NuGenHelperFunctions.ConvertToSingle(parameter);
floatNumberILCode.DecodedParameter = floatNumberILCode.Parameter;
break;
case OpCodeGroup.DoubleParameter:
NumberILCode<double> doubleNumberILCode = new NumberILCode<double>();
code = doubleNumberILCode;
doubleNumberILCode.Parameter = NuGenHelperFunctions.ConvertToDouble(parameter);
doubleNumberILCode.DecodedParameter = doubleNumberILCode.Parameter;
break;
case OpCodeGroup.ByteArgumentParameter:
ArgumentILCode<byte> byteArgumentILCode = new ArgumentILCode<byte>();
code = byteArgumentILCode;
byteArgumentILCode.Parameter = (byte)parameter;
byteArgumentILCode.DecodedParameter = NameOfParameter(parameter);
break;
case OpCodeGroup.UshortArgumentParameter:
ArgumentILCode<ushort> ushortArgumentILCode = new ArgumentILCode<ushort>();
code = ushortArgumentILCode;
ushortArgumentILCode.Parameter = (ushort)parameter;
ushortArgumentILCode.DecodedParameter = NameOfParameter(parameter);
break;
case OpCodeGroup.ByteVariableParameter:
VariableILCode<byte> byteVariableILCode = new VariableILCode<byte>();
code = byteVariableILCode;
byteVariableILCode.Parameter = (byte)parameter;
byteVariableILCode.DecodedParameter = byteVariableILCode.Parameter;
break;
case OpCodeGroup.UshortVariableParameter:
VariableILCode<ushort> ushortVariableILCode = new VariableILCode<ushort>();
code = ushortVariableILCode;
ushortVariableILCode.Parameter = (ushort)parameter;
ushortVariableILCode.DecodedParameter = ushortVariableILCode.Parameter;
break;
case OpCodeGroup.Calli:
NuGenCalliILCode calliILCode = new NuGenCalliILCode();
code = calliILCode;
calliILCode.Parameter = Convert.ToUInt32(parameter);
calliILCode.DecodedParameter = assembly.StandAloneSignatures[calliILCode.Parameter];
break;
case OpCodeGroup.Ldtoken:
NuGenLdtokenILCode ldtokenILCode = new NuGenLdtokenILCode();
code = ldtokenILCode;
ldtokenILCode.Parameter = Convert.ToUInt32(parameter);
ldtokenILCode.DecodedParameter = assembly.AllTokens[ldtokenILCode.Parameter];
if (GenericParameters != null)
{
ldtokenILCode.SetGenericsMethodParameters(assembly.AllTokens, GenericParameters);
}
break;
case OpCodeGroup.Switch:
NuGenSwitchILCode switchILCode = new NuGenSwitchILCode();
code = switchILCode;
ulong addressIndex = 0;
switchILCode.Parameter = new int[parameter];
parameterSize += Convert.ToInt32(parameter * 4);
while (addressIndex < parameter)
{
int jumpAddress = (int)NuGenHelperFunctions.GetILCodeParameter(methodCode, methodCodeIndex + Convert.ToInt32((addressIndex + 1) * 4), 4);
switchILCode.Parameter[addressIndex++] = jumpAddress;
}
break;
}
if (code != null)
{
code.Offset = offset;
code.OpCode = opCode;
code.DecodeParameter();
}
code.Indentation = 1;
CodeLines.Add(code);
methodCodeIndex += parameterSize;
}
}
NuGenCodeLine end = new NuGenCodeLine();
StringBuilder endText = new StringBuilder();
endText.Append("} //end of method ");
if (BaseTypeDefinition.FullName != null && BaseTypeDefinition.FullName.Length > 0)
{
endText.Append(BaseTypeDefinition.FullName);
endText.Append("::");
}
endText.Append(Name);
end.Text = endText.ToString();
CodeLines.Add(end);
if (moreSects)
{
ReadMethodDataSections(assemblyReader);
}
}
if (assembly.IsInMemory)
{
assemblyReader.Close();
}
else
{
assembly.CloseAssemblyReader();
}
}
else
{
NuGenCodeLine end = new NuGenCodeLine();
end.Text = string.Format("}} // end of method {0}{1}{2}", BaseTypeDefinition.Name, (BaseTypeDefinition.Name.Length > 0 ? "::" : string.Empty), Name);
CodeLines.Add(end);
}
}
public void Initialize()
{
ReadMetadata();
NuGenAssembly assembly = BaseTypeDefinition.ModuleScope.Assembly;
CodeLines = new List<NuGenCodeLine>();
NuGenCodeLine definitionLine = new NuGenCodeLine();
definitionLine.Indentation = 0;
CodeLines.Add(definitionLine);
CodeLines.Add(new NuGenCodeLine(0, "{"));
if (CustomAttributes != null)
{
foreach (NuGenCustomAttribute customAttribute in CustomAttributes)
{
customAttribute.SetText(assembly.AllTokens);
CodeLines.Add(new NuGenCodeLine(1, customAttribute.Name));
}
}
if (assembly.AllTokens.ContainsKey(GetterMethodToken))
{
NuGenMethodDefinition getMethod = (NuGenMethodDefinition)assembly.AllTokens[GetterMethodToken];
CodeLines.Add(new NuGenCodeLine(1, ".get " + getMethod.Text));
}
for (int index = 0; index < OtherMethodsCount; index++)
{
uint token = OtherMethods[index];
if (assembly.AllTokens.ContainsKey(token))
{
NuGenMethodDefinition otherMethod = (NuGenMethodDefinition)assembly.AllTokens[token];
CodeLines.Add(new NuGenCodeLine(1, ".other " + otherMethod.Text));
}
}
if (assembly.AllTokens.ContainsKey(SetterMethodToken))
{
NuGenMethodDefinition setMethod = (NuGenMethodDefinition)assembly.AllTokens[setterMethodToken];
CodeLines.Add(new NuGenCodeLine(1, ".set " + setMethod.Text));
}
Definition = ".property " + Definition;
definitionLine.Text = Definition;
CodeLines.Add(new NuGenCodeLine(0, string.Format("}} //end of property {0}::{1}", BaseTypeDefinition.Name, Name)));
}
private void AddExceptionCodeLines(uint offset, uint length, string name, string endComment, bool finallyClause)
{
int start = FindCodeLine(offset);
if (start > -1)
{
int end = FindCodeLine(offset + length);
if (end > -1)
{
int indentation = ((NuGenBaseILCode)CodeLines[start]).Indentation;
for (int ilCodeIndex = start; ilCodeIndex < end; ilCodeIndex++)
{
CodeLines[ilCodeIndex].Indentation++;
}
NuGenCodeLine nameDefinition = new NuGenCodeLine(indentation, name);
NuGenCodeLine bracket = new NuGenCodeLine(indentation, "{");
CodeLines.Insert(start, bracket);
CodeLines.Insert(start, nameDefinition);
end += 2;
if (finallyClause && indentation > 1)
{
indentation--;
}
bracket = new NuGenCodeLine(indentation, string.Format("}} {0}", endComment));
CodeLines.Insert(end, bracket);
}
}
}
private NuGenCodeLine CreateMethodHead(string definition)
{
NuGenCodeLine result = new NuGenCodeLine();
StringBuilder text = new StringBuilder();
text.Append(".method ");
NuGenHelperFunctions.AddWordToStringBuilder(text, MemberAccessAsString());
NuGenHelperFunctions.AddWordToStringBuilder(text, MethodContractAsString());
NuGenHelperFunctions.AddWordToStringBuilder(text, VTableLayoutAsString());
NuGenHelperFunctions.AddWordToStringBuilder(text, MethodImplementationAsString());
NuGenHelperFunctions.AddWordToStringBuilder(text, InteropAttributesAsString());
NuGenHelperFunctions.AddWordToStringBuilder(text, ReservedFlagsAsString());
text.Append(definition);
NuGenHelperFunctions.AddWordToStringBuilder(text, CodeImplementationAsString());
NuGenHelperFunctions.AddWordToStringBuilder(text, ManagedImplementationAsString());
NuGenHelperFunctions.AddWordToStringBuilder(text, ImplementationInfoAsString());
result.Text = text.ToString();
return result;
}
public void Initialize()
{
CodeLines = new List<NuGenCodeLine>();
NuGenCodeLine definition = new NuGenCodeLine(0, "file " + Name);
CodeLines.Add(definition);
CodeLines.Add(new NuGenCodeLine(0, string.Format(".hash = {0}", NuGenHelperFunctions.ReadBlobAsString(Hash, HashLength))));
}
public void Initialize()
{
CodeLines = new List<NuGenCodeLine>();
StringBuilder definitionBuilder = new StringBuilder(".mresource ");
if ((Flags & CorManifestResourceFlags.mrPublic) == CorManifestResourceFlags.mrPublic)
{
definitionBuilder.Append("public ");
}
else
{
definitionBuilder.Append("private ");
}
definitionBuilder.Append(Name);
NuGenCodeLine definition = new NuGenCodeLine(0, definitionBuilder.ToString());
CodeLines.Add(definition);
CodeLines.Add(new NuGenCodeLine(0, "{"));
CodeLines.Add(new NuGenCodeLine(1, string.Format(".file {0} at 0x{1}", Name, NuGenHelperFunctions.FormatAsHexNumber(Offset, 8))));
CodeLines.Add(new NuGenCodeLine(0, "}"));
}
public void Initialize()
{
CodeLines = new List<NuGenCodeLine>();
StringBuilder definition = new StringBuilder();
definition.Append(".assembly extern ");
definition.Append(NuGenHelperFunctions.EnumAsString(Flags, CorAssemblyFlags.afRetargetable, "retargetable "));
definition.Append(Name);
NuGenCodeLine definitionLine = new NuGenCodeLine(0, definition.ToString());
CodeLines.Add(definitionLine);
CodeLines.Add(new NuGenCodeLine(0, "{"));
if (FullPath != null && FullPath.Length > 0)
{
CodeLines.Add(new NuGenCodeLine(1, "//Full Path: " + FullPath));
}
else
{
CodeLines.Add(new NuGenCodeLine(1, "//Full Path: exact location not found. "));
}
CodeLines.Add(new NuGenCodeLine(1, ".publickeytoken = " + NuGenHelperFunctions.ReadBlobAsString(PublicKeyOrToken, PublicKeyOrTokenLength)));
if (HashBlobLength > 0)
{
CodeLines.Add(new NuGenCodeLine(1, ".hash = " + NuGenHelperFunctions.ReadBlobAsString(HashBlob, HashBlobLength)));
}
CodeLines.Add(new NuGenCodeLine(1, string.Format(".ver {0}:{1}:{2}:{3}", Metadata.usMajorVersion, Metadata.usMinorVersion, Metadata.usBuildNumber, Metadata.usRevisionNumber)));
CodeLines.Add(new NuGenCodeLine(0, "} //end of assembly reference " + Name));
}
