private void LoadTypes(TypeDeclarationCollection types, MergeModuleState state) { foreach (var type in types) { LoadType(type, state); } }
private bool BuildTypeRef(TypeReference typeRef, ref ModuleReference moduleRef, ref string name) { MergeModuleState moduleState = null; if (_moduleState != null) { MergeAssemblyState assemblyState; if (!_merge._mergedAssemblyByName.TryGetValue(_moduleState.Module.Assembly.Name, out assemblyState)) { return(false); } if (!assemblyState.ModuleByName.TryGetValue(moduleRef.Name, out moduleState)) { return(false); } } else { if (!_merge._mergedModuleByName.TryGetValue(moduleRef.Name, out moduleState)) { return(false); } } string newName; if (moduleState.RenamedTypeNames.TryGetValue(typeRef, out newName)) { name = newName; } moduleRef = null; return(true); }
private MergeModuleState LoadModule(Module module, MergeDuplicateBehavior duplicateBehavior) { var state = new MergeModuleState(); state.Module = module; state.DuplicateBehavior = duplicateBehavior; LoadTypes(module.Types, state); return(state); }
private void LoadGlobalType(TypeDeclaration type, MergeModuleState state) { if (!type.HasMembers()) { return; } TypeReference typeRef; do { string newName = _random.NextString(12); typeRef = new TypeReference(newName); }while (_typeRefs.Contains(typeRef)); _typeRefs.Add(typeRef); state.Types.Add(type); state.RenamedTypeNames.Add(type.ToReference(), typeRef.Name); }
internal SignatureRelocator(AssemblyMerge merge, MergeModuleState moduleState) { _merge = merge; _moduleState = moduleState; }
private void LoadType(TypeDeclaration type, MergeModuleState state) { if (type.IsGlobal()) { LoadGlobalType(type, state); return; } var typeRef = type.ToReference(); // Check existing type. if (!_typeRefs.Contains(typeRef)) { // Type does not exists. _typeRefs.Add(typeRef); state.Types.Add(type); return; } // Check exported type. Signature exportedTypeOwner; if (_exportedTypeToOwner.TryGetValue(typeRef, out exportedTypeOwner)) { // Type exists as exported type. switch (exportedTypeOwner.SignatureType) { case SignatureType.Module: { var moduleRef = (ModuleReference)exportedTypeOwner; if (state.Module.Name == moduleRef.Name) { _exportedTypeToOwner.Remove(typeRef); state.Types.Add(type); return; } } break; case SignatureType.Assembly: { var assemblyRef = (AssemblyReference)exportedTypeOwner; if (state.Module.Assembly.Name == assemblyRef.Name) { _exportedTypeToOwner.Remove(typeRef); state.Types.Add(type); return; } } break; default: throw new InvalidOperationException(); } } // Type is duplicate. switch (state.DuplicateBehavior) { case MergeDuplicateBehavior.Rename: { int index = 1; var newTypeRef = typeRef; do { string newName = typeRef.Name + (++index).ToString(); newTypeRef = new TypeReference(newName, typeRef.Namespace); }while (_typeRefs.Contains(newTypeRef)); _typeRefs.Add(newTypeRef); state.Types.Add(type); state.RenamedTypeNames.Add(typeRef, newTypeRef.Name); } return; case MergeDuplicateBehavior.Skip: return; case MergeDuplicateBehavior.Throw: throw new AssemblyDefenderException(string.Format(SR.MergeDuplicatedType, type.FullName, type.Module.ToString())); default: throw new InvalidOperationException(); } }
private void MergeModule(MergeModuleState state) { var module = _assembly.Module; var mergedModule = state.Module; var relocator = new SignatureRelocator(this, state); // Types foreach (var type in state.Types) { var mergedType = module.Types.Add(); type.CopyTo(mergedType); relocator.Build(mergedType); bool isGlobal = mergedType.IsGlobal(); var typeRef = mergedType.ToReference(mergedType.Module); string newName; if (state.RenamedTypeNames.TryGetValue(typeRef, out newName)) { mergedType.Name = newName; } if (isGlobal) { MergeGlobalType(mergedType); } } // Assembly references foreach (var assemblyRef in mergedModule.AssemblyReferences) { if (_assembly.Name == assemblyRef.Name) { continue; } if (_mergedAssemblyByName.ContainsKey(assemblyRef.Name)) { continue; } if (!_assemblyRefs.Contains(assemblyRef)) { _assemblyRefs.Add(assemblyRef); } } // Exproted types foreach (var exportedType in mergedModule.ExportedTypes) { var enclosingExportedType = (TypeReference)exportedType.GetOutermostType(); if (!_exportedTypeToOwner.ContainsKey(enclosingExportedType)) { continue; } if (!_exportedTypes.Contains(exportedType)) { _exportedTypes.Add(exportedType); } } }