private static void Patch(string assembly, string assemblyClean, string lizard, string attributes) { // keep original assembly before modification if (!File.Exists(assemblyClean)) { File.Copy(assembly, assemblyClean); } File.Copy(LizardDll, lizard); File.Copy(AttributesDll, attributes); Mono.Cecil.AssemblyDefinition assemblyDefinition = Cecil.ReadAssembly(assembly); if (assemblyDefinition == null) { Externs.MessageBox("Assembly is null", "Failed to load assembly " + assembly); Environment.Exit(-1); } int injectedCorrectly = Util.InjectAllHooks(Attributes, assemblyDefinition); if (injectedCorrectly > 0) { Cecil.WriteChanges(assemblyDefinition); } ModCompiler.CompileMods(); }
private static IEnumerable <IAssemblyReference> LoadReferences(IEnumerable <string> references, IErrorReporter er) { var loader = new CecilLoader { IncludeInternalMembers = true }; var assemblies = references.Select(r => AssemblyDefinition.ReadAssembly(r)).ToList(); // Shouldn't result in errors because mcs would have caught it. var indirectReferences = (from a in assemblies from m in a.Modules from r in m.AssemblyReferences select r.Name) .Distinct(); var directReferences = from a in assemblies select a.Name.Name; var missingReferences = indirectReferences.Except(directReferences).ToList(); if (missingReferences.Count > 0) { er.Region = DomRegion.Empty; foreach (var r in missingReferences) { er.Message(7996, r); } return(null); } return(assemblies.Select(a => loader.LoadAssembly(a)).ToList()); }
public IEnumerable <Mono.Cecil.TypeDefinition> Filter(Mono.Cecil.AssemblyDefinition assembly) { var excludeTypes = excludeList; bool IsCommandPredicate(Mono.Cecil.TypeDefinition t) { if (!t.IsValueType || t.IsPrimitive || (!t.IsIRpcCommand() && !t.IsICommandData())) { return(false); } if (excludeTypes != null && excludeTypes.Contains(t.FullName)) { return(false); } return(!t.HasAttribute <NetCodeDisableCommandCodeGenAttribute>()); } var result = new List <Mono.Cecil.TypeDefinition>(); if (assembly?.Modules != null) { foreach (var m in assembly.Modules) { if (m != null) { result.AddRange(m.GetTypes().Where(IsCommandPredicate)); } } } return(result); }
static private void showString(Mono.Cecil.TypeDefinition type, Mono.Cecil.AssemblyDefinition assembly, string prefix = "") { nestSearch(type, assembly, ref prefix, showString); type.Methods.ToList().ForEach((method) => { var lineCount = 0; if (method.HasBody) { method.Body.Instructions.ToList().ForEach(inst => { if (inst.OpCode == Mono.Cecil.Cil.OpCodes.Ldstr) { if (lineCount == 0) { Console.WriteLine(string.Format("{0}.{1}:", prefix, method.Name)); } Console.WriteLine(string.Format("{0}:{1}", lineCount, inst.Operand.ToString())); lineCount++; } }); } if (lineCount != 0) { Console.WriteLine(); } }); }
static private void debugMethod(Mono.Cecil.TypeDefinition type, Mono.Cecil.AssemblyDefinition assembly, string prefix = "") { nestSearch(type, assembly, ref prefix, debugMethod); type.Methods.ToList().ForEach((method) => { var il = method.Body.GetILProcessor(); var module = type.Module; var write = il.Create( Mono.Cecil.Cil.OpCodes.Call, module.Import(typeof(Console).GetMethod("WriteLine", new[] { typeof(object) }))); var ret = il.Create(Mono.Cecil.Cil.OpCodes.Ret); var leave = il.Create(Mono.Cecil.Cil.OpCodes.Leave, ret); il.InsertAfter( method.Body.Instructions.Last(), write); il.InsertAfter(write, leave); il.InsertAfter(leave, ret); var handler = new Mono.Cecil.Cil.ExceptionHandler(Mono.Cecil.Cil.ExceptionHandlerType.Catch) { TryStart = method.Body.Instructions.First(), TryEnd = write, HandlerStart = write, HandlerEnd = ret, CatchType = module.Import(typeof(Exception)), }; method.Body.ExceptionHandlers.Add(handler); }); }
public static string DetectTargetFrameworkId(Mono.Cecil.AssemblyDefinition assembly, string assemblyPath = null) { if (assembly == null) { throw new ArgumentNullException(nameof(assembly)); } const string TargetFrameworkAttributeName = "System.Runtime.Versioning.TargetFrameworkAttribute"; foreach (var attribute in assembly.CustomAttributes) { if (attribute.AttributeType.FullName != TargetFrameworkAttributeName) { continue; } if (attribute.HasConstructorArguments) { if (attribute.ConstructorArguments[0].Value is string value) { return(value); } } } // Optionally try to detect target version through assembly path as a fallback (use case: reference assemblies) if (assemblyPath != null) { /* * Detected path patterns (examples): * * - .NETFramework -> C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.6.1\mscorlib.dll * - .NETCore -> C:\Program Files\dotnet\sdk\NuGetFallbackFolder\microsoft.netcore.app\2.1.0\ref\netcoreapp2.1\System.Console.dll * -> C:\Program Files\dotnet\packs\Microsoft.NETCore.App.Ref\3.0.0\ref\netcoreapp3.0\System.Runtime.Extensions.dll * - .NETStandard -> C:\Program Files\dotnet\sdk\NuGetFallbackFolder\netstandard.library\2.0.3\build\netstandard2.0\ref\netstandard.dll */ var pathMatch = Regex.Match(assemblyPath, DetectTargetFrameworkIdRefPathPattern, RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.ExplicitCapture); if (pathMatch.Success) { var type = pathMatch.Groups[1].Value; var version = pathMatch.Groups[2].Value; if (type == ".NETFramework") { return($".NETFramework,Version=v{version}"); } else if (type.ToLower().Contains("netcore")) { return($".NETCoreApp,Version=v{version}"); } else if (type.ToLower().Contains("netstandard")) { return($".NETStandard,Version=v{version}"); } } } return(string.Empty); }
private static GACAssembly QueryAssemblyInfo(string assemblyString) { string assemblyPath = AssemblyCache.QueryAssemblyInfo(assemblyString); Mono.Cecil.AssemblyDefinition assemblyDefinition = Mono.Cecil.AssemblyDefinition.ReadAssembly(assemblyPath); return(new GACAssembly(assemblyDefinition.Name.Name, assemblyDefinition.Name.Version, assemblyPath, assemblyDefinition.MainModule.Runtime.ToString(), KeyTokenToString(assemblyDefinition.Name.PublicKeyToken))); }
public static bool IsReferenceAssembly(Mono.Cecil.AssemblyDefinition assemblyDef, string assemblyFile) { if (assemblyDef.CustomAttributes.Any(ca => ca.AttributeType.FullName == "System.Runtime.CompilerServices.ReferenceAssemblyAttribute")) { return(true); } // Try to detect reference assembly through specific path pattern var refPathMatch = Regex.Match(assemblyFile, RefPathPattern, RegexOptions.IgnoreCase | RegexOptions.Compiled); return(refPathMatch.Success); }
private static void OptimizeAssembly( Mono.Cecil.AssemblyDefinition cecilAsm, ClrAssembly flameAsm, Func <ClrMethodDefinition, MethodBody> optimizeBody) { foreach (var module in cecilAsm.Modules) { foreach (var type in module.Types) { OptimizeType(type, flameAsm, optimizeBody); } } }
public IEnumerable <Mono.Cecil.TypeDefinition> Filter(Mono.Cecil.AssemblyDefinition assembly) { bool IsEnginedSupportedType(Mono.Cecil.TypeDefinition type) { if (GhostAuthoringComponentEditor.GhostDefaultOverrides.TryGetValue(type.FullName.Replace("/", "+"), out var newComponent)) { return(true); } return(false); } var excludeTypes = excludeList; bool IsGhostPredicate(Mono.Cecil.TypeDefinition t) { if (!t.IsValueType || t.IsPrimitive || !t.IsIComponentData() || t.IsIRpcCommand()) { return(false); } if (excludeTypes != null && excludeTypes.Contains(t.FullName)) { return(false); } // Backward compatibility for Transform and Rotation and other default types here. // Customize the below method in case you need to add more if (IsEnginedSupportedType(t)) { return(true); } // Otherwise, for backward compatibility I need to scan for presence of any GhostField. return(t.HasFields && t.Fields.Any(f => f.HasAttribute <GhostFieldAttribute>())); } var result = new List <Mono.Cecil.TypeDefinition>(); if (assembly?.Modules != null) { foreach (var m in assembly.Modules) { if (m != null) { result.AddRange(m.GetTypes().Where(IsGhostPredicate)); } } } return(result); }
public static string FindAssemblyFile(Mono.Cecil.AssemblyDefinition assemblyDefinition, string assemblyFile) { string tfi = DetectTargetFrameworkId(assemblyDefinition, assemblyFile); UniversalAssemblyResolver assemblyResolver; if (IsReferenceAssembly(assemblyDefinition, assemblyFile)) { assemblyResolver = new UniversalAssemblyResolver(null, throwOnError: false, tfi); } else { assemblyResolver = new UniversalAssemblyResolver(assemblyFile, throwOnError: false, tfi); } return(assemblyResolver.FindAssemblyFile(AssemblyNameReference.Parse(assemblyDefinition.Name.FullName))); }
private static IEnumerable <TypeDefinition> GetTypesFromDll(string dllPath) { var dll = Assembly.LoadFile(dllPath); var typesToReturn = new List <Type>(); try { return(AssemblyDefinition.ReadAssembly(dllPath).MainModule.Types.Where(_ => _.CustomAttributes.Any(x => x.AttributeType.FullName == GenerateCustomAttribute))); } catch (Exception e) { Console.WriteLine(e.Message); return(new List <TypeDefinition>()); } }
public Mono.Cecil.ModuleDefinition GetModuleZ(String DllFilename) { if (_AssemblyCache.ContainsKey(DllFilename)) { return(_AssemblyCache[DllFilename].MainModule); } FileInfo DllFile = null; if (!Path.IsPathRooted(DllFilename)) { if (File.Exists(Path.Combine(_ApplicationPath, DllFilename))) { DllFile = new FileInfo(Path.Combine(_ApplicationPath, DllFilename)); } else if (File.Exists(PathZ.Combine(_ApplicationPath, "StarshipTheory_Data", DllFilename))) { DllFile = new FileInfo(PathZ.Combine(_ApplicationPath, "StarshipTheory_Data", DllFilename)); } else if (File.Exists(PathZ.Combine(_ApplicationPath, "StarshipTheory_Data", "Managed", DllFilename))) { DllFile = new FileInfo(PathZ.Combine(_ApplicationPath, "StarshipTheory_Data", "Managed", DllFilename)); } else if (File.Exists(PathZ.Combine(AppDomain.CurrentDomain.BaseDirectory, DllFilename))) { DllFile = new FileInfo(PathZ.Combine(AppDomain.CurrentDomain.BaseDirectory, DllFilename)); } } else if (File.Exists(DllFilename)) { DllFile = new FileInfo(DllFilename); } if (DllFile == null) { return(null); } Mono.Cecil.AssemblyDefinition Def = Mono.Cecil.AssemblyDefinition.ReadAssembly(DllFile.FullName); if (Def != null) { _AssemblyCache[DllFilename] = Def; return(Def.MainModule); } return(null); }
static private void nestSearch(Mono.Cecil.TypeDefinition type, Mono.Cecil.AssemblyDefinition assembly, ref string prefix, _delegate del) { if (prefix != "") { prefix += "."; } if (type.Namespace != "") { prefix += type.Namespace + "."; } prefix += type.Name; var _prefix = prefix; type.NestedTypes.ToList().ForEach(x => { del(x, assembly, _prefix); }); }
public static BuildArtifact Get(byte[] data) { BuildArtifact art = new BuildArtifact(); using (MemoryStream ms = new MemoryStream(data)) { try { Mono.Cecil.AssemblyDefinition def = Mono.Cecil.AssemblyDefinition.ReadAssembly(ms); Mono.Cecil.AssemblyNameReference defn = Mono.Cecil.AssemblyNameDefinition.Parse(def.FullName); art.Version = defn.Version.ToString(); art.Name = defn.Name; art.IsAssembly = true; } catch { } } art.Data = data; return(art); }
static int Main(string[] args) { if (args.Length < 2) { Console.WriteLine("[?] Usage: cfg.exe MyAssembly.dll Namespace.Class.Method[:n]"); return(-1); } var location = args[1].Split(new[] { '.' }); if (location.Length < 3) { Console.WriteLine("[-] Please provide full path to the method - Namespace.Class.Method[:n]"); return(-2); } var len = location.Length; var className = location[len - 2]; var methodName = location[len - 1]; int skip = 0; if (methodName.Contains(':')) { var noOfMethod = methodName.Split(':'); methodName = noOfMethod[0]; int.TryParse(noOfMethod[1], out skip); } var namespaceName = String.Join(".", location.TakeWhile(x => x != className)); AssemblyDefinition definition = AssemblyDefinition.ReadAssembly(args[0]); var targetMethod = definition.MainModule.Types.First(x => x.Namespace == namespaceName && x.Name == className).Methods .Where(x => x.Name == methodName).Skip(skip).First(); Console.WriteLine("digraph CFG {"); Console.WriteLine("node [shape=box]"); //first instruction is always a leader var leadersToVisit = new List <Instruction> { targetMethod.Body.Instructions.First() }; var edges = new List <Edge>(); foreach (var instruction in targetMethod.Body.Instructions.Skip(1)) { switch (instruction.OpCode.FlowControl) { case FlowControl.Cond_Branch: var leaders = instruction.Operand is Instruction[] switchTargets ? switchTargets : new[] { instruction.Operand as Instruction }; leaders = leaders.Append(instruction.Next).ToArray(); leadersToVisit.AddRange(leaders); edges.AddRange(leaders.Select(x => new Edge { From = instruction, To = x })); break; case FlowControl.Branch: var branchTarget = instruction.Operand as Instruction; leadersToVisit.Add(branchTarget); edges.Add(new Edge { From = instruction, To = instruction.Operand as Instruction }); var previousInstruction = (instruction.Operand as Instruction).Previous; edges.Add(new Edge { From = previousInstruction, To = branchTarget }); break; case FlowControl.Return: if (instruction.Next != null) { leadersToVisit.Add(instruction.Next); } break; } } var distinctLeaders = leadersToVisit.Distinct(new OpCodeEqualityComparer()).ToArray(); Array.Sort(distinctLeaders, new OpCodeComparer()); var reverseLeadersBBs = new Dictionary <Instruction[], Instruction>(); for (var i = 0; i < distinctLeaders.Length - 1; i++) { var leader = distinctLeaders[i]; var nextLeader = distinctLeaders[i + 1]; var bb = targetMethod.Body.Instructions .SkipWhile(x => x.Offset < leader.Offset) .TakeWhile(x => x.Offset < nextLeader.Offset) .ToArray(); reverseLeadersBBs.Add(bb, leader); PrintBB(leader, bb); } var lastLeader = distinctLeaders.Last(); var lastLeaderBB = targetMethod.Body.Instructions.SkipWhile(x => x.Offset < lastLeader.Offset).ToArray(); PrintBB(lastLeader, lastLeaderBB); reverseLeadersBBs.Add(lastLeaderBB, lastLeader); foreach (var edge in edges) { var leader = reverseLeadersBBs.First(x => x.Key.Select(y => y.Offset) .Contains(edge.From.Offset)).Value; PrintEdge(leader, edge.To); } Console.WriteLine("}"); return(0); }
public void SetUp() { strategy = new TrackNUnitTestMethods(); assemblyDefinition = Mono.Cecil.AssemblyDefinition.ReadAssembly(typeof(TrackNUnitTestMethodsTests).Assembly.Location); }
protected abstract IEnumerable<TMethod> CollectConstructors (TType type); // Must return all instance ctors. May return static ctors too (they're automatically filtered out). protected abstract bool ContainsPlatformReference (TAssembly assembly); // returns true if the assembly is monotouch.dll too.
protected abstract string GetAssemblyName (TAssembly assembly);
public void GetTestAssembly() { TestAssembly = MonoCecilTypeSystemHelper.GetTestAssemlyDefinition(); }
public void GetTestAssembly() { TestAssembly = MonoCecilAssemblyHelper.GetTestAssemlyDefinition(); }
public List <AssemblyObject> Read(List <string> assemblies) { List <AssemblyObject> result = new List <AssemblyObject>(); foreach (string assembly in assemblies) { string directory = Directory.GetCurrentDirectory(); if (assembly.StartsWith("System")) { // TODO: This needs more love before we include .Net modules //directory = RuntimeEnvironment.GetRuntimeDirectory(); continue; } Mono.Cecil.AssemblyDefinition definition = Mono.Cecil.AssemblyDefinition.ReadAssembly(System.IO.Path.Combine(directory, assembly)); foreach (Mono.Cecil.ModuleDefinition module in definition.Modules) { foreach (Mono.Cecil.TypeDefinition type in module.Types) { string name = type.Name; string ns = type.Namespace; bool found = false; foreach (string allowed in _Namespaces) { if (ns.StartsWith(allowed)) { found = true; break; } } if (!found) { continue; } AssemblyObject working = result.FirstOrDefault(a => a.Namespace == ns); if (working == null) { working = new AssemblyObject() { Name = ns, Namespace = ns }; result.Add(working); } AssemblyObject o = new AssemblyObject() { Name = name, Namespace = ns }; if (type.HasFields) { foreach (Mono.Cecil.FieldDefinition f in type.Fields) { if (f.IsPublic) { string fname = f.Name; o.Fields.Add(new AssemblyObject() { Name = fname }); } } } if (type.HasProperties) { foreach (Mono.Cecil.PropertyDefinition p in type.Properties) { string pname = p.Name; o.Properties.Add(new AssemblyObject() { Name = pname }); } } if (type.HasMethods) { foreach (Mono.Cecil.MethodDefinition m in type.Methods) { if (m.IsPublic) { string mname = m.Name; if (!mname.StartsWith("get_") || !mname.StartsWith("set_")) { continue; } AssemblyObject mo = new AssemblyObject() { Name = mname }; if (m.HasParameters) { foreach (Mono.Cecil.ParameterDefinition r in m.Parameters) { string rname = r.Name; mo.Methods.Add(new AssemblyObject() { Name = rname }); } } o.Methods.Add(mo); } } } working.Children.Add(o); } } } return(result); }
public static MonoSymbolFile ReadSymbolFile(Mono.Cecil.AssemblyDefinition assembly, string filename) { string name = filename + ".mdb"; return(new MonoSymbolFile(name, assembly)); }
protected abstract IEnumerable<TType> CollectTypes (TAssembly assembly);
public static void Inject(string input_assembly_path, string output_assembly_path, string logger_assembly_path, string logger_type_name, string before_call_log_method_name, string log_attribute_name) { System.Diagnostics.Debug.Assert(System.IO.File.Exists(input_assembly_path)); if (input_assembly_path != output_assembly_path) { if (System.IO.File.Exists(output_assembly_path)) { System.IO.File.Delete(output_assembly_path); } System.IO.File.Copy(input_assembly_path, output_assembly_path); System.Diagnostics.Debug.Assert(System.IO.File.Exists(output_assembly_path)); } var assembly_resolver = new Mono.Cecil.DefaultAssemblyResolver(); string input_assembly_directory = System.IO.Path.GetDirectoryName(input_assembly_path); assembly_resolver.AddSearchDirectory(input_assembly_directory); #if SILVERLIGHT Microsoft.Silverlight.Build.Tasks.GetSilverlightFrameworkPath path_task = new Microsoft.Silverlight.Build.Tasks.GetSilverlightFrameworkPath(); path_task.RegistryBase = "Software\\Microsoft\\Microsoft SDKs\\Silverlight"; path_task.Execute(); assembly_resolver.AddSearchDirectory(path_task.SilverlightPath); foreach (string path in path_task.SilverlightSDKPaths) { assembly_resolver.AddSearchDirectory(path); } #endif Mono.Cecil.AssemblyDefinition injectible_assembly = Mono.Cecil.AssemblyDefinition.ReadAssembly(output_assembly_path, new Mono.Cecil.ReaderParameters { AssemblyResolver = assembly_resolver }); System.Diagnostics.Debug.Assert(System.IO.File.Exists(logger_assembly_path)); Mono.Cecil.AssemblyDefinition logger_assembly = Mono.Cecil.AssemblyDefinition.ReadAssembly(logger_assembly_path); Mono.Cecil.TypeDefinition logger_type = logger_assembly.MainModule.GetType(logger_type_name); System.Diagnostics.Debug.Assert(logger_type != null); Mono.Cecil.MethodDefinition before_callback_method_info = logger_type.Methods.First(m => m.Name == before_call_log_method_name); Mono.Cecil.MethodReference before_callback_reference = injectible_assembly.MainModule.Import(before_callback_method_info); //make sure to get System.Object.ToString method from assembly compatible with the injected assembly #if SILVERLIGHT string core_assembly_path = path_task.SilverlightPath + "mscorlib.dll"; Mono.Cecil.AssemblyDefinition core_assembly = Mono.Cecil.AssemblyDefinition.ReadAssembly(core_assembly_path); Mono.Cecil.TypeDefinition object_type = core_assembly.MainModule.GetType("System.Object"); Mono.Cecil.MethodDefinition to_string_method_info = object_type.Methods.First(m => m.Name == "ToString"); #else System.Reflection.MethodInfo to_string_method_info = typeof(System.Object).GetMethod("ToString"); #endif Mono.Cecil.MethodReference to_string_reference = injectible_assembly.MainModule.Import(to_string_method_info); foreach (Mono.Cecil.TypeDefinition type_definition in injectible_assembly.MainModule.Types) { bool is_type_logable = type_definition.CustomAttributes.Any(a => a.AttributeType.FullName == log_attribute_name); foreach (Mono.Cecil.MethodDefinition method_definition in type_definition.Methods) { bool is_method_logable = is_type_logable || method_definition.CustomAttributes.Any(a => a.AttributeType.FullName == log_attribute_name); if (is_method_logable) { Mono.Cecil.Cil.ILProcessor processor = method_definition.Body.GetILProcessor(); System.Collections.Generic.List <Mono.Cecil.Cil.Instruction> original_instructions = new System.Collections.Generic.List <Mono.Cecil.Cil.Instruction>(); original_instructions.AddRange(method_definition.Body.Instructions); method_definition.Body.Instructions.Clear(); #region parameters int method_parameters_count = method_definition.Parameters.Count; int local_variables_count = method_definition.Body.Variables.Count; int arguments_array_index = local_variables_count; // Create an array of type System.String with the same number of elements as count of method parameters // Add metadata for a new variable of type System.String[] to method body // .locals init (System.String[] V_0) Mono.Cecil.ArrayType arguments = new Mono.Cecil.ArrayType(injectible_assembly.MainModule.TypeSystem.String); method_definition.Body.Variables.Add(new Mono.Cecil.Cil.VariableDefinition((Mono.Cecil.TypeReference)arguments)); method_definition.Body.InitLocals = true; method_definition.Body.Instructions.Add(processor.Create(Mono.Cecil.Cil.OpCodes.Ldc_I4, method_parameters_count)); method_definition.Body.Instructions.Add(processor.Create(Mono.Cecil.Cil.OpCodes.Newarr, injectible_assembly.MainModule.TypeSystem.String)); // This instruction will store the address of the newly created array in the newly added local variable, which is at index = local_variables_count method_definition.Body.Instructions.Add(processor.Create(Mono.Cecil.Cil.OpCodes.Stloc, arguments_array_index)); #region parameters_to_string // Instance methods have an an implicit argument called "this" // so in that case we need to refer to actual arguments with +1 position int parameter_offset = method_definition.IsStatic ? 0 : 1; for (int i = 0; i < method_parameters_count; ++i) { // load argument array and current index method_definition.Body.Instructions.Add(processor.Create(Mono.Cecil.Cil.OpCodes.Ldloc, arguments_array_index)); method_definition.Body.Instructions.Add(processor.Create(Mono.Cecil.Cil.OpCodes.Ldc_I4, i)); // load argument method_definition.Body.Instructions.Add(processor.Create(Mono.Cecil.Cil.OpCodes.Ldarga, i + parameter_offset)); // convert argument to string Mono.Cecil.TypeReference argument_type = method_definition.Parameters[i].ParameterType; method_definition.Body.Instructions.Add(processor.Create(Mono.Cecil.Cil.OpCodes.Constrained, argument_type)); method_definition.Body.Instructions.Add(processor.Create(Mono.Cecil.Cil.OpCodes.Callvirt, to_string_reference)); // store string in array method_definition.Body.Instructions.Add(processor.Create(Mono.Cecil.Cil.OpCodes.Stelem_Ref)); } #endregion parameters_to_string string method_signature = method_definition.ToString(); // load method signature method_definition.Body.Instructions.Add(processor.Create(Mono.Cecil.Cil.OpCodes.Ldstr, method_signature)); // load parameters array method_definition.Body.Instructions.Add(processor.Create(Mono.Cecil.Cil.OpCodes.Ldloc, arguments_array_index)); #endregion parameters // load before call instruction method_definition.Body.Instructions.Add(processor.Create(Mono.Cecil.Cil.OpCodes.Call, before_callback_reference)); foreach (var IL in original_instructions) { method_definition.Body.Instructions.Add(IL); } } } } injectible_assembly.Write(output_assembly_path); }
public void RegisterAssembly (TAssembly assembly) { if (assembly == null) throw new ArgumentNullException ("assembly"); if (assemblies.ContainsKey (assembly)) return; if (!ContainsPlatformReference (assembly)) { assemblies.Add (assembly, null); return; } if (SkipRegisterAssembly (assembly)) { Trace ("[ASSEMBLY] Skipped registration for {0}", GetAssemblyName (assembly)); return; } var exceptions = new List<Exception> (); try { var types = CollectTypes (assembly); Trace ("[ASSEMBLY] Registering {0}", assembly.ToString ()); // Normally this method is only called at startup, when we're still // single-threaded. In this case it makes sense to lock as seldom as // possible, so instead of locking 'types' once for every type, we // lock it once for all of them. lock (this.types) { foreach (TType type in types) { //Trace (" Checking {0}", GetTypeFullName (type)); if (HasModelAttribute (type)) { Trace ("{0} is a model: not registering it", GetTypeFullName (type)); continue; } RegisterTypeUnsafe (type, ref exceptions); } } assemblies.Add (assembly, null); } catch (Exception e) { ReportError (4116, "Could not register the assembly '{0}': {1}", GetAssemblyName (assembly), e); } FlushTrace (); if (exceptions.Count > 0) { Exception ae = exceptions.Count == 1 ? exceptions [0] : new AggregateException (exceptions); #if !MTOUCH Console.WriteLine (ae); #endif throw ae; } }
protected MonoSymbolFile(string filename, Mono.Cecil.AssemblyDefinition assembly) : this(filename) { Guid mvid = assembly.MainModule.Mvid; CheckGuidMatch(mvid, filename, assembly.MainModule.Image.FileInformation.FullName); }
public IEnumerable <Mono.Cecil.TypeDefinition> Filter(Mono.Cecil.AssemblyDefinition assembly) { bool IsEnginedSupportedType(Mono.Cecil.TypeDefinition type) { if (GhostAuthoringModifiers.GhostDefaultOverrides.TryGetValue(type.FullName.Replace("/", "+"), out var newComponent)) { return(true); } return(false); } var excludeTypes = excludeList; bool IsGhostPredicate(Mono.Cecil.TypeDefinition t) { if (!t.IsValueType || t.IsPrimitive || t.IsIRpcCommand()) { return(false); } if (t.HasCustomAttributes) { var variant = t.GetAttribute <GhostComponentVariationAttribute>(); if (variant != null) { return(true); } } if (!(t.IsIComponentData() || t.IsBufferElementData() || t.IsICommandData())) { return(false); } if (excludeTypes != null && excludeTypes.Contains(t.FullName)) { return(false); } // Backward compatibility for Transform and Rotation and other default types here. // Customize the below method in case you need to add more if (IsEnginedSupportedType(t)) { return(true); } return((t.HasFields && t.Fields.Any(f => f.IsPublic && f.HasAttribute <GhostFieldAttribute>())) || (t.HasProperties && t.Properties.Any(f => f.GetMethod != null && f.GetMethod.IsPublic && f.SetMethod != null && f.SetMethod.IsPublic && f.HasAttribute <GhostFieldAttribute>()))); } var result = new List <Mono.Cecil.TypeDefinition>(); if (assembly?.Modules != null) { foreach (var m in assembly.Modules) { if (m != null) { result.AddRange(m.GetTypes().Where(IsGhostPredicate)); } } } return(result); }
protected virtual bool SkipRegisterAssembly (TAssembly assembly) { return false; }