Exemplo n.º 1
0
        private Model.Types.MethodDefinition GetMainDefinitionInAnalysisNetAssembly(Model.Assembly assembly)
        {
            IEnumerable <Model.Types.MethodDefinition> mainQuery = from t in assembly.RootNamespace.GetAllTypes()
                                                                   from m in t.Members.OfType <Model.Types.MethodDefinition>()
                                                                   where m.IsStatic && m.Name.Equals("Main")
                                                                   select m;

            Model.Types.MethodDefinition main = mainQuery.SingleOrDefault();

            return(main);
        }
Exemplo n.º 2
0
        // before yielding type def A it yields every nested type in A
        // it could be improved by doing an iterative dfs
        public static IEnumerable <Model.Types.TypeDefinition> TraverseTypes(this Model.Assembly assembly)
        {
            ISet <Model.Types.TypeDefinition> visited = new HashSet <Model.Types.TypeDefinition>();

            foreach (Model.Types.TypeDefinition typeDefinition in Model.Types.TypeHelper.GetAllTypes(assembly.RootNamespace))
            {
                if (visited.Contains(typeDefinition))
                {
                    continue;
                }

                foreach (Model.Types.TypeDefinition t in DFS(typeDefinition, visited))
                {
                    yield return(t);
                }
            }
        }
Exemplo n.º 3
0
        private void CreateDefinitions(ModelMapping modelMapping)
        {
            IDictionary <Model.Assembly, AssemblyDefinition> assembliesMap = modelMapping.AssembliesMap;

            foreach (KeyValuePair <Model.Assembly, AssemblyDefinition> keyval in assembliesMap)
            {
                AssemblyDefinition cecilAssembly       = keyval.Value;
                Model.Assembly     analysisNetAssembly = keyval.Key;

                ReferenceGenerator referenceGen = new ReferenceGenerator(new Context(cecilAssembly.MainModule, modelMapping, Host));

                // TraverseTypes returns every nested type in A before returning A
                // this is assumed by the TypeGenerator and MethodGenerator
                foreach (Model.Types.TypeDefinition analysisNetType in analysisNetAssembly.TraverseTypes())
                {
                    TypeGenerator             typeGenerator = new TypeGenerator(referenceGen);
                    Mono.Cecil.TypeDefinition cecilTypeDef  = typeGenerator.TypeDefinition(analysisNetType);

                    // nested types are not added directly to the main module
                    // instead they are added to their enclosing type (that's the way cecil works)
                    if (cecilTypeDef.DeclaringType == null)
                    {
                        cecilAssembly.MainModule.Types.Add(cecilTypeDef);
                    }

                    foreach (Model.Types.MethodDefinition analysisNetMethod in analysisNetType.Methods)
                    {
                        MethodGenerator methodGenerator = new MethodGenerator(referenceGen);
                        cecilTypeDef.Methods.Add(methodGenerator.MethodDefinition(analysisNetMethod));
                    }

                    // we need to have every method definition created
                    typeGenerator.PropertyDefinitions(analysisNetType, cecilTypeDef);
                }
            }
        }