public ClassOrValueTypeSig Type(bool isValueType, string ns, string name, IResolutionScope resolutionScope)
{
var typeRef = module.UpdateRowId(new TypeRefUser(module, ns, name, resolutionScope));
ClassOrValueTypeSig type;
if (isValueType)
{
type = new ValueTypeSig(typeRef);
}
else
{
type = new ClassSig(typeRef);
}
return((ClassOrValueTypeSig)Add(type));
}
public EmbeddedAssemblyInfo UnpackMainAssembly(bool createAssembly)
{
if (mainAsmResource == null)
{
return(null);
}
var info = CreateEmbeddedAssemblyInfo(mainAsmResource, Decrypt(mainAsmResource));
var asm = module.Assembly;
if (createAssembly && asm != null && entryPointToken != 0 && info.kind == ModuleKind.NetModule)
{
info.extension = DeobUtils.GetExtension(module.Kind);
info.kind = module.Kind;
var realAsm = module.UpdateRowId(new AssemblyDefUser(asm.Name, new Version(0, 0, 0, 0)));
info.realAssemblyInfo = new RealAssemblyInfo(realAsm, entryPointToken, info.kind);
if (module.Name != "Stub.exe")
{
info.realAssemblyInfo.moduleName = module.Name.String;
}
info.asmFullName = realAsm.FullName;
info.asmSimpleName = realAsm.Name.String;
}
return(info);
}
public void initialize()
{
foreach (var kv in getMovedTypes())
{
var structType = kv.Key;
structToOwners.add(structType, kv.Value);
foreach (var ownerType in kv.Value)
{
foreach (var ownerField in ownerType.Fields)
{
if (DotNetUtils.getType(module, ownerField.FieldSig.GetFieldType()) != structType)
{
continue;
}
structFieldsToFix.add(ownerField, true);
break;
}
var fieldsDict = new FieldDefAndDeclaringTypeDict <FieldDef>();
typeToFieldsDict.add(ownerType, fieldsDict);
foreach (var structField in structType.Fields)
{
var newField = module.UpdateRowId(new FieldDefUser(structField.Name, structField.FieldSig.Clone(), structField.Attributes));
ownerType.Fields.Add(newField);
fieldsDict.add(structField, newField);
}
}
}
}
private static TypeRef GetTypeRef(ModuleDefMD assemblyModule, string @namespace, string name, IResolutionScope assemblyRef)
{
var typeRefUser = new TypeRefUser(assemblyModule, @namespace, name, assemblyRef);
if (typeRefUser.ResolutionScope == null)
{
throw new InvalidOperationException("ResolutionScope must not be null.");
}
return(assemblyModule.UpdateRowId <TypeRefUser>(typeRefUser));
}
public IMethod ReadMethodRef()
{
var babelMethodRef = new MethodRefReader(this).Read();
var method = GetMethodRef(babelMethodRef);
if (method == null)
{
throw new ApplicationException($"Could not find method '{Utils.RemoveNewlines(babelMethodRef.Name)}' in type '{Utils.RemoveNewlines(babelMethodRef.DeclaringType)}'");
}
var git = babelMethodRef.DeclaringType.ToGenericInstSig();
if (git == null)
{
return(method);
}
var mr = new MemberRefUser(module, method.Name, method.MethodSig.Clone(), babelMethodRef.DeclaringType.ToTypeDefOrRef());
return(module.UpdateRowId(mr));
}
private void PatchNuclearUpgrade_EquipmentType(ModuleDefMD module)
{
var equipmentType = module.Find("EquipmentType", false);
FieldDef fieldToAdd =
new FieldDefUser("NuclearReactorOrCyclopsModule", new FieldSig(new ValueTypeSig(equipmentType)))
{
Constant = module.UpdateRowId(new ConstantUser(NuclearUpgradeHelper.NuclearReactorOrCyclopsModule,
equipmentType.GetEnumUnderlyingType().ElementType)),
Attributes = FieldAttributes.Literal | FieldAttributes.Static | FieldAttributes.HasDefault |
FieldAttributes.Public
};
equipmentType.Fields.Add(fieldToAdd);
}
void InitializeCtors(TypeDef manager, MethodDefAndDeclaringTypeDict <IMethod> ctors)
{
if (manager == null)
{
return;
}
foreach (var ctor in manager.Methods)
{
if (ctor.Name != ".ctor")
{
continue;
}
var newCtor = new MemberRefUser(module, ctor.Name, ctor.MethodSig.Clone(), manager.BaseType);
module.UpdateRowId(newCtor);
ctors.Add(ctor, newCtor);
}
}
private static AssemblyRef GetCallingConventionAssemblyRefForNetCore(ModuleDefMD module, string callingConventionAssemblyName)
{
var numAsmRefs = module.TablesStream.AssemblyRefTable.Rows;
foreach (var assemblyRef in module.GetAssemblyRefs())
{
if (assemblyRef is null)
{
continue;
}
if (assemblyRef.Name == callingConventionAssemblyName)
{
return(assemblyRef);
}
}
var compilerServicesAssembly = new AssemblyRefUser(module.Context.AssemblyResolver.ResolveThrow(new AssemblyRefUser(callingConventionAssemblyName), module));
module.UpdateRowId(compilerServicesAssembly);
return(compilerServicesAssembly);
}
