Esempio n. 1
0
        public void ShouldGenerateComplexClass()
        {
            var nsp   = Noast.Create <INamespace>("MyProject.Complex");
            var cla   = Noast.Create <IClass>("Person", nsp).With(Visibility.Public);
            var field = Noast.Create <IField>("cellCount").With(Visibility.Private);

            field.Type = typeof(ulong).FullName;
            cla.Fields.Add(field);
            var meth = Noast.Create <IMethod>("get_Id").With(Visibility.Internal);

            meth.ReturnType = typeof(Guid).FullName;
            cla.Methods.Add(meth);
            meth = Noast.Create <IMethod>("add_IdChanged").With(Visibility.Protected);
            meth.AddParameter("handler", typeof(EventHandler).FullName);
            cla.Methods.Add(meth);
            meth = Noast.Create <IMethod>(".ctor").With(Visibility.ProtectedInternal);
            meth.AddParameter("id", typeof(Guid).FullName);
            meth.AddParameter("name", typeof(string).FullName);
            cla.Methods.Add(meth);
            meth            = Noast.Create <IMethod>("op_Inequality").With(Visibility.Public);
            meth.ReturnType = typeof(bool).FullName;
            meth.AddParameter("first", "Person");
            meth.AddParameter("second", "Person");
            cla.Methods.Add(meth);
            meth = Noast.Create <IMethod>("get_Item").With(Visibility.Public);
            meth.AddParameter("index", typeof(int).FullName);
            meth.ReturnType = typeof(string).FullName;
            cla.Methods.Add(meth);
            Console.WriteLine(nsp);
        }
Esempio n. 2
0
        public void ShouldGenerateMetadata()
        {
            var myInfo = Noast.Create <IMetadata>("Super.Awesome.Lib");

            myInfo.AddUsing("System");
            myInfo.AddUsing("System.Diagnostics");
            myInfo.AddUsing("System.Reflection");
            myInfo.AddUsing("System.Runtime.CompilerServices");
            myInfo.Version                  = new Version("4.6.1.0");
            myInfo.ClsCompliant             = true;
            myInfo.Company                  = "Autofac";
            myInfo.Configuration            = "Debug";
            myInfo.Copyright                = "Copyright © 2015 Autofac Contributors";
            myInfo.Description              = "Autofac Inversion of Control container for .NET applications.";
            myInfo.Alias                    = "Autofac";
            myInfo.InternalVersion          = "4.6.1-develop-00422";
            myInfo.Product                  = "Autofac";
            myInfo.Title                    = "Autofac";
            myInfo.NeutralLocale            = "en-US";
            myInfo.ComVisible               = false;
            myInfo.Trademark                = "";
            myInfo.Culture                  = "en-GB";
            myInfo.Guid                     = Guid.NewGuid();
            myInfo.Metadata["Author"]       = "PhD Franz Schuster";
            myInfo.Metadata["CreationDate"] = "August 23 2011";
            myInfo.Metadata["Website"]      = "www.google.de";
            myInfo.TargetFramework          = "4.5";
            Console.WriteLine(myInfo);
        }
Esempio n. 3
0
        public void ShouldGenerateStruct()
        {
            var myStruct = Noast.Create <IStruct>("MyStruct").With(Visibility.Public);

            myStruct.AddAttribute(typeof(SerializableAttribute).FullName);
            Console.WriteLine(myStruct);
        }
Esempio n. 4
0
        public void ShouldGenerateAbstractClass()
        {
            var myClass = Noast.Create <IClass>("A").With(Visibility.Public).With(Modifier.Abstract);
            var myMeth  = Noast.Create <IMethod>("DoWork").Accepts("i @ int")
                          .With(Visibility.Public).With(Modifier.Abstract);

            myClass.Methods.Add(myMeth);
            Console.WriteLine(myClass);
            myClass = Noast.Create <IClass>("D").With(Visibility.Public);
            myMeth  = Noast.Create <IMethod>("DoWork").Accepts("i @ int")
                      .With(Visibility.Public).With(Modifier.Virtual);
            myClass.Methods.Add(myMeth);
            Console.WriteLine(myClass);
            myClass          = Noast.Create <IClass>("E").With(Visibility.Public).With(Modifier.Abstract);
            myClass.BaseType = Noast.Create <IBase>("D");
            myMeth           = Noast.Create <IMethod>("DoWork").Accepts("i @ int")
                               .With(Visibility.Public).With(Modifier.Abstract).With(Modifier.Override);
            myClass.Methods.Add(myMeth);
            Console.WriteLine(myClass);
            myClass          = Noast.Create <IClass>("F").With(Visibility.Public);
            myClass.BaseType = Noast.Create <IBase>("E");
            myMeth           = Noast.Create <IMethod>("DoWork").Accepts("i @ int")
                               .With(Visibility.Public).With(Modifier.Override);
            myClass.Methods.Add(myMeth);
            Console.WriteLine(myClass);
            myClass = Noast.Create <IClass>("D").With(Visibility.Public).With(Modifier.Sealed);
            Console.WriteLine(myClass);
            myClass          = Noast.Create <IClass>("D").With(Visibility.Public);
            myClass.BaseType = Noast.Create <IBase>("C");
            myMeth           = Noast.Create <IMethod>("DoWork")
                               .With(Visibility.Public).With(Modifier.Sealed).With(Modifier.Override);
            myClass.Methods.Add(myMeth);
            Console.WriteLine(myClass);
        }
Esempio n. 5
0
        public void ShouldGenerateInterface()
        {
            var myIntf = Noast.Create <IInterface>("MyInterface").With(Visibility.Public);

            myIntf.AddImplements(typeof(IDisposable).FullName);
            myIntf.AddImplements(typeof(ICloneable).FullName);
            Console.WriteLine(myIntf);
        }
Esempio n. 6
0
        private static IMethod CreateSwitchMethod()
        {
            var meth = Noast.Create <IMethod>("GetInstance").With(Visibility.Public).With(Modifier.Static);

            meth.ReturnType = "Api.IPlatform";
            meth.Body       = "if (Environment.OSVersion.Platform == PlatformID.Win32NT) return new Win32Platform(); return new MonoPlatform();";
            return(meth);
        }
Esempio n. 7
0
        public void ShouldGenerateCustomIndexer()
        {
            var myIndx = Noast.Create <IIndexer>("MyIndexer").Accepts("int").With(Visibility.Public);

            myIndx.Getter = "return null;";
            myIndx.Setter = "return;";
            Console.WriteLine(myIndx);
        }
Esempio n. 8
0
        public void ShouldGenerateEnum()
        {
            var myEnum = Noast.Create <IEnum>("MyEnum").With(Visibility.Public);

            myEnum.AddValue("Test1");
            myEnum.AddValue("Test2");
            myEnum.AddValue("Test3");
            Console.WriteLine(myEnum);
        }
Esempio n. 9
0
        public void ShouldGenerateClass()
        {
            var myClass = Noast.Create <IClass>("MyClass").With(Visibility.Public)
                          .ChildOf(typeof(Delegate).FullName);

            myClass.AddImplements(typeof(IDisposable).FullName);
            myClass.AddImplements(typeof(ICloneable).FullName);
            Console.WriteLine(myClass);
        }
Esempio n. 10
0
        private static IMetadata CreateMetadata(string file, string replaces)
        {
            var name = Path.GetFileNameWithoutExtension(file);
            var meta = Noast.Create <IMetadata>(name);

            meta.AddUsing("System.Runtime.Versioning");
            meta.TargetFramework             = "4.5";
            meta.Metadata[Defaults.Creator]  = typeof(Purger).Namespace;
            meta.Metadata[Defaults.Replaces] = replaces;
            return(meta);
        }
Esempio n. 11
0
        private static IEnumerable <Tuple <IMethod, MethodDefinition> > CollectPInvokes(AssemblyDefinition ass)
        {
            var methodSigs = new List <string>();

            foreach (var type in ass.GetAllTypes())
            {
                foreach (var meth in type.Methods)
                {
                    if (meth.HasPInvokeInfo)
                    {
                        var pinv = meth.PInvokeInfo;
                        var name = meth.Name;
                        if (!Enumerable.Range('A', 26).Contains(name[0]))
                        {
                            name = pinv.EntryPoint;
                        }
                        if (name.StartsWith("#", StringComparison.InvariantCulture))
                        {
                            name = Path.GetFileNameWithoutExtension(pinv.Module.Name) + name.Substring(1);
                        }
                        var key = (pinv.Module.Name + "/" + pinv.EntryPoint + "/" + name).ToLowerInvariant();
                        if (methodSigs.Contains(key))
                        {
                            continue;
                        }
                        var gen = Noast.Create <IMethod>(name);
                        gen.ReturnType = meth.ReturnType.Name;
                        var attr = Noast.Create <IAttribute>(typeof(DllImportAttribute).Name);
                        attr.Values.Add($"\"{pinv.Module}\"");
                        attr.Properties["CharSet"]      = pinv.ToCharset();
                        attr.Properties["SetLastError"] = pinv.SupportsLastError;
                        var entryPoint = pinv.EntryPoint;
                        attr.Properties["EntryPoint"] = $"\"{entryPoint}\"";
                        gen.Attributes.Add(attr);
                        foreach (var parm in meth.Parameters)
                        {
                            AddParam(parm, gen);
                        }
                        methodSigs.Add(key);
                        if (Type.GetType(meth.ReturnType.FullName) == null)
                        {
                            continue;
                        }
                        if (meth.Parameters.Any(p => Type.GetType(p.ParameterType.FullName) == null))
                        {
                            continue;
                        }
                        yield return(Tuple.Create(gen, meth));
                    }
                }
            }
        }
Esempio n. 12
0
        public void ShouldGenerateAll()
        {
            var aNsp = Noast.Create <INamespace>("System.IO.Nasa");

            aNsp.AddUsing(typeof(StringBuilder).Namespace);
            var aStruct  = Noast.Create <IStruct>("HelloStruct", aNsp);
            var anEnum   = Noast.Create <IEnum>("HelloEnum", aNsp);
            var anInterf = Noast.Create <IInterface>("HelloInterf", aNsp);
            var aClass   = Noast.Create <IClass>("HelloClass", aNsp);
            var aDeleg   = Noast.Create <IDelegate>("HelloDelegate", aNsp);

            Console.WriteLine(aNsp);
        }
Esempio n. 13
0
        public void ShouldGeneratePartialClass()
        {
            var myClass = Noast.Create <IClass>("MyPartClass").With(Visibility.Public)
                          .With(Modifier.Partial);

            myClass.AddImplements(typeof(IDisposable).FullName);
            Console.WriteLine(myClass);
            myClass = Noast.Create <IClass>("MyPartClass").With(Visibility.Public)
                      .With(Modifier.Partial);
            var myMeth = Noast.Create <IMethod>("Dispose").With(Visibility.Public);

            myClass.Methods.Add(myMeth);
            Console.WriteLine(myClass);
        }
Esempio n. 14
0
        public void ShouldGenerateOperator()
        {
            // Manual
            var myOp = Noast.Create <IOperator>("UnaryPlus").With(Modifier.Static).With(Visibility.Public);

            Console.WriteLine(myOp);
            // Automatic
            var myClass = Noast.Create <IClass>("Autogen");
            var op      = Noast.Create <IMethod>("op_UnaryPlus").With(Visibility.Public);

            myClass.Methods.Add(op);
            Console.WriteLine(myClass);
            // Compare
            Assert.AreEqual(myOp.ToString(), myClass.ToString());
        }
Esempio n. 15
0
        public void ShouldGenerateInitializer()
        {
            // Manual
            var myCnstr = Noast.Create <IConstructor>("MyConstructor").With(Modifier.Static);

            Console.WriteLine(myCnstr);
            // Automatic
            var myClass = Noast.Create <IClass>("Autogen");
            var cstr    = Noast.Create <IMethod>(".cctor");

            myClass.Methods.Add(cstr);
            Console.WriteLine(myClass);
            // Compare
            Assert.AreEqual(myCnstr.ToString(), myClass.ToString());
        }
Esempio n. 16
0
        public void ShouldGenerateNoEvent()
        {
            var myClass = Noast.Create <IInterface>("IImageList");
            var adder   = Noast.Create <IMethod>("Add").With(Visibility.Public);

            adder.AddParameter("listener", typeof(IntPtr).FullName);
            myClass.Methods.Add(adder);
            var remover = Noast.Create <IMethod>("Remove").With(Visibility.Public);

            remover.AddParameter("listener", typeof(int).FullName);
            myClass.Methods.Add(remover);
            Console.WriteLine(myClass);
            // Check it
            Assert.AreEqual(0, myClass.Events.Count);
            Assert.AreEqual(2, myClass.Methods.Count);
        }
Esempio n. 17
0
        public void ShouldGenerateCustomProps()
        {
            var intf = Noast.Create <IInterface>("MyIntf");

            intf.Methods.Add(Noast.Create <IMethod>("get_ReadOnly").Returns("string"));
            intf.Methods.Add(Noast.Create <IMethod>("set_WriteOnly").Accepts("char"));
            intf.Methods.Add(Noast.Create <IMethod>("get_ReadWrite").Returns("Stream"));
            intf.Methods.Add(Noast.Create <IMethod>("set_ReadWrite").Accepts("Stream"));
            intf.Methods.Add(Noast.Create <IMethod>("add_AutoEvent").Accepts("EventHandler"));
            intf.Methods.Add(Noast.Create <IMethod>("remove_AutoEvent").Accepts("EventHandler"));
            intf.Methods.Add(Noast.Create <IMethod>("get_ReadOnly").Accepts("byte").Returns("string"));
            intf.Methods.Add(Noast.Create <IMethod>("set_WriteOnly").Accepts("short", "string"));
            intf.Methods.Add(Noast.Create <IMethod>("get_ReadWrite").Accepts("int").Returns("string"));
            intf.Methods.Add(Noast.Create <IMethod>("set_ReadWrite").Accepts("int", "string"));
            Console.WriteLine(intf);
        }
Esempio n. 18
0
        private static void AddParam(ParameterDefinition parm, IMethod gen)
        {
            var name = parm.Name;

            if (!Enumerable.Range('A', 26).Contains(name.FirstOrDefault()))
            {
                name = "p" + gen.Parameters.Count;
            }
            var par = Noast.Create <IParameter>(name);

            par.Type = Simplify(parm.ParameterType.Name);
            if (parm.ParameterType.IsByReference)
            {
                par.Modifier = ParamModifier.Ref;
            }
            gen.Parameters.Add(par);
        }
Esempio n. 19
0
        private static IEnumerable <IMethod> DelegateInterface(IMethod externMeth)
        {
            var meth = Noast.Create <IMethod>($"{prefix}{externMeth.Name}");   // TODO: method cloning?! externMeth

            yield return(meth);

            meth            = Noast.Create <IMethod>(externMeth.Name).With(Visibility.Public);
            meth.ReturnType = externMeth.ReturnType;
            var preamble = meth.ReturnType.ToLowerInvariant() == "void" ? "" : "return ";
            var parms    = string.Join(", ", externMeth.Parameters.Select(p => (p.IsRef() ? "ref " : "") + p.Name));

            meth.Body = $"{preamble}{prefix}{externMeth.Name}({parms});";
            foreach (var parm in externMeth.Parameters)
            {
                meth.Parameters.Add(parm);
            }
            yield return(meth);
        }
Esempio n. 20
0
        public void ShouldGenerateMethod()
        {
            var myMeth = Noast.Create <IMethod>("MyMethod").With(Visibility.Public);
            var attr   = myMeth.AddAttribute(typeof(DllImportAttribute).FullName);

            attr.Values.Add("cfgmgr32.dll");
            attr.Values.Add(44);
            attr.Values.Add(true);
            attr.Properties["Entrypoint"]   = "Calc";
            attr.Properties["Count"]        = 43;
            attr.Properties["SetLastError"] = true;
            myMeth.ReturnType = typeof(long).FullName;
            myMeth.Body       = "System.Console.WriteLine(\"Hello world!\");" +
                                "throw new System.InvalidOperationException();";
            myMeth.AddParameter("a", "int");
            myMeth.AddParameter("b", "int", ParamModifier.Ref);
            myMeth.AddParameter("c", "int", ParamModifier.Out);
            Console.WriteLine(myMeth);
        }
Esempio n. 21
0
        private static void GenerateMembers(AType holder, IType type)
        {
            var fldHolder = holder as IHasFields;

            if (fldHolder != null)
            {
                foreach (var fld in type.Fields.Values)
                {
                    var myFld = Noast.Create <IField>(fld.Name);
                    myFld.Type = Simplify(DerivedClassDeobfuscate(fld.Type));
                    fldHolder.Fields.Add(myFld);
                }
            }
            var methHolder = holder as IHasMethods;

            if (methHolder != null)
            {
                foreach (var meth in type.Methods.Values)
                {
                    var myMeth    = Noast.Create <IMethod>(meth.Name);
                    var parmIndex = 0;
                    foreach (var parm in meth.Parameters)
                    {
                        var parmName = parm.Name;
                        if (string.IsNullOrWhiteSpace(parmName))
                        {
                            parmName = $"parm{parmIndex++}";
                        }
                        parmName = ToName(Deobfuscate(parmName));
                        var parmType = Simplify(DerivedClassDeobfuscate(parm.Type));
                        var parmMod  = default(ParamModifier?);
                        if (parm.Type.EndsWith("&"))
                        {
                            parmMod = ParamModifier.Ref;
                        }
                        myMeth.AddParameter(parmName, parmType, parmMod);
                    }
                    myMeth.ReturnType = Simplify(DerivedClassDeobfuscate(meth.ReturnType));
                    methHolder.Methods.Add(myMeth);
                }
            }
        }
Esempio n. 22
0
        private static IEnumerable <IMethod> ImplementInterface(IMethod externMeth)
        {
            var meth = Noast.Create <IMethod>(externMeth.Name).With(Visibility.Public);

            meth.ReturnType = externMeth.ReturnType;
            // meth.Body = $"throw new NotImplementedException(\"Sorry!\");";
            if (meth.ReturnType.ToLowerInvariant() == "void")
            {
                meth.Body = "return;";
            }
            else
            {
                meth.Body = $"return default({meth.ReturnType});";
            }
            foreach (var parm in externMeth.Parameters)
            {
                meth.Parameters.Add(parm);
            }
            yield return(meth);
        }
Esempio n. 23
0
        public void ShouldGenerateEvent()
        {
            // Manual
            var myEvent = Noast.Create <IEvent>("MyEvent").With(Visibility.Public);

            Console.WriteLine(myEvent);
            // Automatic
            var myClass = Noast.Create <IClass>("Autogen");
            var adder   = Noast.Create <IMethod>("add_MyEvent").With(Visibility.Public);

            adder.AddParameter("listener", typeof(object).FullName);
            myClass.Methods.Add(adder);
            var remover = Noast.Create <IMethod>("remove_MyEvent").With(Visibility.Public);

            remover.AddParameter("listener", typeof(object).FullName);
            myClass.Methods.Add(remover);
            Console.WriteLine(myClass);
            // Compare
            Assert.AreEqual(myEvent.ToString(), myClass.ToString());
        }
Esempio n. 24
0
        public void ShouldGenerateProperty()
        {
            // Manual
            var myProp = Noast.Create <IProperty>("MyProperty").With(Visibility.Public);

            Console.WriteLine(myProp);
            // Automatic
            var myClass = Noast.Create <IClass>("Autogen");
            var getter  = Noast.Create <IMethod>("get_MyProperty").With(Visibility.Public);

            getter.ReturnType = typeof(object).FullName;
            myClass.Methods.Add(getter);
            var setter = Noast.Create <IMethod>("set_MyProperty").With(Visibility.Public);

            setter.AddParameter("value", typeof(object).FullName);
            myClass.Methods.Add(setter);
            Console.WriteLine(myClass);
            // Compare
            Assert.AreEqual(myProp.ToString(), myClass.ToString());
        }
Esempio n. 25
0
        public void ShouldGenerateDelegate()
        {
            var myDlgt = Noast.Create <IDelegate>("MyDelegate").With(Visibility.Public);

            Console.WriteLine(myDlgt);
        }
Esempio n. 26
0
        internal static int Clean(PurifyOptions opts)
        {
            var files = GetAssemblyFiles(opts.WorkDir).Where(f => !f.Contains(".OS.")).ToArray();

            log.Info($"Found {files.Length} files!");
            var resolv = new DefaultAssemblyResolver();

            resolv.AddSearchDirectory(opts.WorkDir);
            var rparam = new ReaderParameters {
                AssemblyResolver = resolv
            };
            var wparam = new WriterParameters();
            var halDir = Path.Combine(opts.CodeDir);

            halDir = Directory.CreateDirectory(halDir).FullName;
            foreach (var file in files)
            {
                using (var stream = new MemoryStream(File.ReadAllBytes(file)))
                {
                    var ass = AssemblyDefinition.ReadAssembly(stream, rparam);
                    log.Info($" - '{ass.FullName}'");
                    var methods = CollectPInvokes(ass).ToList();
                    if (!methods.Any())
                    {
                        continue;
                    }
                    var apiName  = ass.Name.Name + ".OS.Api";
                    var apiCS    = Path.Combine(halDir, apiName + ".cs");
                    var implName = ass.Name.Name + ".OS.Impl";
                    var implCS   = Path.Combine(halDir, implName + ".cs");
                    using (var pinvoke = File.CreateText(apiCS))
                    {
                        var nsp = Noast.Create <INamespace>(apiName);
                        nsp.AddUsing("System");
                        nsp.AddUsing("System.Runtime.InteropServices");
                        nsp.AddUsing("System.Runtime.InteropServices.ComTypes");
                        nsp.AddUsing("System.Text");
                        var cla = Noast.Create <IInterface>("IPlatform", nsp);
                        foreach (var meth in methods.Select(m => m.Item1))
                        {
                            cla.Methods.Add(meth);
                        }
                        pinvoke.Write(nsp);
                    }
                    string f;
                    var    apiCSAss = Compiler.CreateAssembly(string.Empty, apiName, new[] { apiCS });
                    File.Copy(apiCSAss.Location, f = Path.Combine(halDir, apiName + ".dll"), true);
                    log.Info($"   --> '{Path.GetFileName(apiCS)}' ({Path.GetFileName(f)})");
                    var apiAssDef = AssemblyDefinition.ReadAssembly(f, rparam);
                    using (var pinvoke = File.CreateText(implCS))
                    {
                        var nsp = Noast.Create <INamespace>(implName);
                        nsp.AddUsing("System");
                        nsp.AddUsing("System.Runtime.InteropServices");
                        nsp.AddUsing("System.Runtime.InteropServices.ComTypes");
                        nsp.AddUsing("System.Text");
                        var cla = Noast.Create <IClass>("Win32Platform", nsp).With(Visibility.Internal);
                        cla.AddImplements(apiName + ".IPlatform");
                        foreach (var meth in methods.Select(m => m.Item1).SelectMany(DelegateInterface))
                        {
                            cla.Methods.Add(meth);
                        }
                        cla = Noast.Create <IClass>("MonoPlatform", nsp).With(Visibility.Internal);
                        cla.AddImplements(apiName + ".IPlatform");
                        foreach (var meth in methods.Select(m => m.Item1).SelectMany(ImplementInterface))
                        {
                            cla.Methods.Add(meth);
                        }
                        cla = Noast.Create <IClass>("Platforms", nsp).With(Visibility.Public).With(Modifier.Static);
                        cla.Methods.Add(CreateSwitchMethod());
                        pinvoke.Write(nsp);
                    }
                    var implCSAss = Compiler.CreateAssembly(string.Empty, implName, new[] { implCS }, new[] { f });
                    File.Copy(implCSAss.Location, f = Path.Combine(halDir, implName + ".dll"), true);
                    log.Info($"   --> '{Path.GetFileName(implCS)}' ({Path.GetFileName(f)})");
                    var implAssDef = AssemblyDefinition.ReadAssembly(f, rparam);
                    var iplat      = apiAssDef.GetAllTypes().First(t => t.Name == "IPlatform");
                    var platfs     = implAssDef.GetAllTypes().First(t => t.Name == "Platforms");
                    var platGet    = platfs.Methods.First();
                    PurifyCalls(methods.Select(m => m.Item2), platGet, iplat);
                    log.InfoFormat("   added '{0}'!", CopyTypeRef(apiCSAss, opts.WorkDir));
                    log.InfoFormat("   added '{0}'!", CopyTypeRef(implCSAss, opts.WorkDir));
                    ass.Write(file, wparam);
                }
            }
            resolv.Dispose();
            return(0);
        }
Esempio n. 27
0
        public void ShouldGenerateField()
        {
            var myField = Noast.Create <IField>("MyField").With(Visibility.Public);

            Console.WriteLine(myField);
        }
Esempio n. 28
0
        private static IEnumerable <KeyValuePair <string, INamespace> > GenerateNamespaces(IDependencyReport report)
        {
            ICodeValidator validator = new MethodDeduper();

            foreach (var pair in report.Units)
            {
                var ass      = pair.Value;
                var fileName = $"{ass.Name}.cs";
                var groups   = pair.Value.Types.GroupBy(u => u.Value.Namespace);
                foreach (var group in groups)
                {
                    var nspName = Deobfuscate(group.Key);
                    var nsp     = Noast.Create <INamespace>(nspName);
                    nsp.AddUsing("System");
                    nsp.AddUsing("System.Text");
                    foreach (var twik in group)
                    {
                        var type    = twik.Value;
                        var kind    = type.Kind;
                        var rawName = DerivedClassDeobfuscate(type.Name).Replace("`1", "");
                        var name    = rawName;
                        if (!IsAttribute(type) && (HasNativeMethod(type) || kind == TypeKind.Struct || kind == TypeKind.Class))
                        {
                            kind = TypeKind.Interface;
                            if (HasNativeMethod(type))
                            {
                                name = $"I{name}";
                            }
                        }
                        var cstrs = type.Methods.Where(m => m.Value.Name.Equals(Defaults.InstConstrName)).ToArray();
                        if (cstrs.Any() && !IsAttribute(type))
                        {
                            var factType = Noast.Create <IInterface>($"I{rawName}Factory", nsp).With(Visibility.Public);
                            foreach (var cstr in cstrs)
                            {
                                var factMethod = Noast.Create <IMethod>($"Create{rawName}");
                                factMethod.ReturnType = name;
                                foreach (var parm in cstr.Value.Parameters)
                                {
                                    var fparm = Noast.Create <IParameter>(parm.Name);
                                    fparm.Type = parm.Type;
                                    factMethod.Parameters.Add(fparm);
                                }
                                factType.Methods.Add(factMethod);
                                type.Methods.Remove(cstr.Key);
                            }
                        }
                        switch (kind)
                        {
                        case TypeKind.Interface:
                            var intf = Noast.Create <IInterface>(name, nsp).With(Visibility.Public);
                            GenerateMembers(intf, type);
                            validator.Validate(intf);
                            break;

                        case TypeKind.Struct:
                            var stru = Noast.Create <IStruct>(name, nsp).With(Visibility.Public);
                            GenerateMembers(stru, type);
                            validator.Validate(stru);
                            break;

                        case TypeKind.Class:
                            var clas = Noast.Create <IClass>(name, nsp).With(Visibility.Public);
                            GenerateMembers(clas, type);
                            validator.Validate(clas);
                            break;

                        case TypeKind.Delegate:
                            var dlgt   = Noast.Create <IDelegate>(name, nsp).With(Visibility.Public);
                            var invoke = type.Methods.Single();
                            foreach (var parm in invoke.Value.Parameters)
                            {
                                dlgt.AddParameter(parm.Name, Simplify(parm.Type));
                            }
                            break;

                        case TypeKind.Enum:
                            var enm = Noast.Create <IEnum>(name, nsp).With(Visibility.Public);
                            foreach (var val in type.Values)
                            {
                                enm.AddValue(val.Value.Name);
                            }
                            break;
                        }
                    }
                    yield return(new KeyValuePair <string, INamespace>(fileName, nsp));
                }
            }
        }
Esempio n. 29
0
        public void ShouldGenerateIndexer()
        {
            var myIndx = Noast.Create <IIndexer>("MyIndexer").Accepts("int").With(Visibility.Public);

            Console.WriteLine(myIndx);
        }
Esempio n. 30
0
        public void ShouldGenerateParameter()
        {
            var myParm = Noast.Create <IParameter>("myParam");

            Console.WriteLine(myParm);
        }