예제 #1
0
 /// <summary>
 /// Default ctor
 /// </summary>
 public TargetFramework(ITypeMapResolver resolver, AssemblyClassLoader assemblyClassLoader, DocModel xmlModel, Action<string> missingParamTypeReport, bool importAsStubs, bool importPublicOnly, IEnumerable<string> excludedPackages)
 {
     this.missingParamTypeReport = missingParamTypeReport;
     this.importAsStubs = importAsStubs;
     this.importPublicOnly = importPublicOnly;
     XmlModel = xmlModel;
     typeNameMap = new TypeNameMap(resolver, assemblyClassLoader);
     this.excludedPackages = new HashSet<string>(excludedPackages);
 }
예제 #2
0
 /// <summary>
 /// Link all references.
 /// </summary>
 internal override void Link(DocModel model)
 {
     foreach (var id in innerClassIds)
     {
         DocClass @class;
         if (model.TryGetClassById(id, out @class))
         {
             innerClasses.Add(@class);
         }
     }
 }
예제 #3
0
 /// <summary>
 /// Default ctor
 /// </summary>
 internal DocDescription(XElement element, DocModel model)
 {
     this.element = element;
     this.model = model;
 }
예제 #4
0
파일: Program.cs 프로젝트: rfcclub/dot42
        /// <summary>
        /// Entry point
        /// </summary>
        internal static int Main(string[] args)
        {
            try
            {
#if DEBUG
                if (args.Length == 0)
                {
                    var assemblyFolder = Path.GetDirectoryName(typeof (Program).Assembly.Location);
                    var folder = Path.GetFullPath(Path.Combine(assemblyFolder, @"..\..\..\..\Sources\Framework\Generated"));
                    var sdkRoot = Path.GetFullPath(Path.Combine(assemblyFolder, @"..\..\..\..\Binaries"));
                    var xmlFolder = Path.GetFullPath(Path.Combine(assemblyFolder, @"..\..\..\Android\Docs\xml"));
                    var forwardAssembliesFolder = Path.GetFullPath(Path.Combine(assemblyFolder, @"..\..\..\..\Sources\Framework\ForwardAssemblies"));
                    //var sdkRoot = Environment.GetEnvironmentVariable("ANDROID_SDK_ROOT");
                    if (string.IsNullOrEmpty(sdkRoot))
                        throw new ArgumentException("Set ANDROID_SDK_ROOT environment variable");
                    var platformFolder = Path.Combine(sdkRoot, @"platforms\android-15");
                    args = new[] {
                        ToolOptions.InputJar.CreateArg(Path.Combine(platformFolder, "Android.jar")),
                        ToolOptions.InputAttrsXml.CreateArg(Path.Combine(platformFolder, @"data\res\values\attrs.xml")),
                        ToolOptions.InputSourceProperties.CreateArg(Path.Combine(platformFolder, "source.properties")),
                        ToolOptions.OutputFolder.CreateArg(folder),
                        //ToolOptions.DoxygenXmlFolder.CreateArg(xmlFolder),
                        //ToolOptions.PublicKeyToken.CreateArg("0a72796057571e65"),
                        ToolOptions.ForwardAssembliesFolder.CreateArg(forwardAssembliesFolder)
                    };
                }
#endif

                var options = new CommandLineOptions(args);
                if (options.ShowHelp)
                {
                    options.Usage();
                    return 2;
                }

                if (!File.Exists(options.FrameworkJar))
                {
                    throw new ArgumentException(string.Format("Framework jar ({0}) not found.", options.FrameworkJar));
                }

                if (!File.Exists(options.SourceProperties))
                {
                    throw new ArgumentException(string.Format("Source.properties ({0}) not found.", options.SourceProperties));                    
                }
                var sdkPropertiesPath = Path.Combine(Path.GetDirectoryName(options.SourceProperties), "sdk.properties");
                if (!File.Exists(sdkPropertiesPath))
                {
                    throw new ArgumentException(string.Format("sdk.properties ({0}) not found.", sdkPropertiesPath));
                }

                // Load source.properties
                var sourceProperties = new SourceProperties(options.SourceProperties);

                using (var jf = new JarFile(File.Open(options.FrameworkJar, FileMode.Open, FileAccess.Read), AttributeConstants.Dot42Scope, null))
                {
                    // Create output folder
                    var folder = Path.Combine(options.OutputFolder, sourceProperties.PlatformVersion);
                    Directory.CreateDirectory(folder);

                    if (!options.VersionOnly)
                    {
                        // Load Doxygen model
                        var xmlModel = new DocModel();
                        using (Profiler.Profile(x => Console.WriteLine("Load XML took {0}ms", x.TotalMilliseconds)))
                        {
                            xmlModel.Load(options.DoxygenXmlFolder);
                        }

                        // Create mscorlib
                        CreateFrameworkAssembly(jf, xmlModel, sourceProperties, folder);

                        // Copy AndroidManifest.xml into the assembly.
                        var manifestStream = jf.GetResource("AndroidManifest.xml");

                        // Copy resources.arsc into the assembly.
                        var resourcesStream = jf.GetResource("resources.arsc");

                        // Load attrs.xml into memory
                        var attrsXml = File.ReadAllBytes(options.AttrsXml);

                        // Load layout.xml into memory
                        var layoutXml = File.ReadAllBytes(Path.Combine(folder, "layout.xml"));

                        // Create base package
                        var basePackagePath = Path.Combine(folder, "base.apk");
                        using (var fileStream = new FileStream(basePackagePath, FileMode.Create, FileAccess.Write))
                        {
                            using (var zipStream = new ZipOutputStream(fileStream) {UseZip64 = UseZip64.Off})
                            {
                                zipStream.SetLevel(9);

                                zipStream.PutNextEntry(new ZipEntry("AndroidManifest.xml")
                                {CompressionMethod = CompressionMethod.Deflated});
                                zipStream.Write(manifestStream, 0, manifestStream.Length);
                                zipStream.CloseEntry();

                                zipStream.PutNextEntry(new ZipEntry("resources.arsc")
                                {CompressionMethod = CompressionMethod.Deflated});
                                zipStream.Write(resourcesStream, 0, resourcesStream.Length);
                                zipStream.CloseEntry();

                                zipStream.PutNextEntry(new ZipEntry(@"attrs.xml")
                                {CompressionMethod = CompressionMethod.Deflated});
                                zipStream.Write(attrsXml, 0, attrsXml.Length);
                                zipStream.CloseEntry();

                                zipStream.PutNextEntry(new ZipEntry(@"layout.xml")
                                {CompressionMethod = CompressionMethod.Deflated});
                                zipStream.Write(layoutXml, 0, layoutXml.Length);
                                zipStream.CloseEntry();
                            }
                        }

                        // Create output folder file
                        if (!string.IsNullOrEmpty(options.OutputFolderFile))
                        {
                            File.WriteAllText(options.OutputFolderFile, folder);
                        }
                    }

                    // Create output version file
                    var version =
                        string.Format(File.ReadAllText(Path.Combine(folder, "..", "..", "Header.txt")), "Version.cs") + Environment.NewLine +
                        string.Format("[assembly: System.Reflection.AssemblyVersion(\"{0}\")]", sourceProperties.AssemblyVersion) + Environment.NewLine +
                        string.Format("[assembly: System.Reflection.AssemblyFileVersion(\"{0}\")]", sourceProperties.AssemblyFileVersion) + Environment.NewLine +
                        string.Format("[assembly: System.Reflection.AssemblyInformationalVersion(\"{0}\")]", sourceProperties.AssemblyInformationalVersion) + Environment.NewLine +
                        "#if !BASELIB" + Environment.NewLine +
                        string.Format("[assembly: System.Runtime.Versioning.TargetFramework(\"Dot42,Version={0}\", FrameworkDisplayName = \"Dot42\")]", sourceProperties.PlatformVersion) + Environment.NewLine +
                        "#endif" + Environment.NewLine;
                    File.WriteAllText(Path.Combine(folder, "Version.cs"), version);

                    if (!options.VersionOnly)
                    {
                        // Load sdk.properties
                        var sdkProperties = new SdkProperties(sdkPropertiesPath);

                        // Create framework ini
                        var frameworkIni = new FrameworkIni(folder);
                        Initialize(frameworkIni, sourceProperties, sdkProperties);
                        frameworkIni.Save();

                        // Create FrameworkList.xml
                        FrameworkListBuilder.Build(folder, options.ForwardAssembliesFolder, null,
                                                   sourceProperties.AssemblyVersion, sourceProperties.PlatformVersion);
                    }
                }

                return 0;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
#if DEBUG
                Console.WriteLine(ex.StackTrace);
#endif
                return 1;
            }
        }
예제 #5
0
파일: Program.cs 프로젝트: rfcclub/dot42
        /// <summary>
        /// Create Dot42.dll
        /// </summary>
        private static void CreateFrameworkAssembly(JarFile jf, DocModel xmlModel, SourceProperties sourceProperties, string folder)
        {
            // Initialize all
            MappedTypeBuilder.Initialize(CompositionContainer);

            // Create java type wrappers
            var module = new NetModule(AttributeConstants.Dot42Scope);
            var classLoader = new AssemblyClassLoader(null);
            var target = new TargetFramework(null, classLoader, xmlModel, LogMissingParamNamesType, true, false, Enumerable.Empty<string>());

            List<TypeBuilder> typeBuilders;
            using (Profiler.Profile(x => Console.WriteLine("Create took {0}ms", x.TotalMilliseconds)))
            {
                var classTypeBuilders = jf.ClassNames.SelectMany(n => StandardTypeBuilder.Create(jf.LoadClass(n), target));
                var customTypeBuilder = CompositionContainer.GetExportedValues<ICustomTypeBuilder>().OrderBy(x => x.CustomTypeName).Select(x => x.AsTypeBuilder());

                typeBuilders = classTypeBuilders.Concat(customTypeBuilder).OrderBy(x => x.Priority).ToList();
                typeBuilders.ForEach(x => x.CreateType(null, module, target));
            }

            // Create JavaRef attribute
            //JavaRefAttributeBuilder.Build(asm.MainModule);

            // Implement and finalize types
            using (Profiler.Profile(x => Console.WriteLine("Implement took {0}ms", x.TotalMilliseconds)))
            {
                JarImporter.Implement(typeBuilders, target);
            }

            // Save
            using (Profiler.Profile(x => Console.WriteLine("Generate took {0}ms", x.TotalMilliseconds)))
            {
                CodeGenerator.Generate(folder, module.Types, new List<NetCustomAttribute>(), target, new FrameworkCodeGeneratorContext(), target);
            }

            // Create layout.xml
            var doc = new XDocument(new XElement("layout"));
            typeBuilders.ForEach(x => x.FillLayoutXml(jf, doc.Root));
            doc.Save(Path.Combine(folder, "layout.xml"));
        }
예제 #6
0
 /// <summary>
 /// Default ctor
 /// </summary>
 internal DocDescription(XElement element, DocModel model)
 {
     this.element = element;
     this.model   = model;
 }
예제 #7
0
        /// <summary>
        /// Does my method match the given documentation?
        /// </summary>
        private bool Matches(DocMethod arg, bool matchParamTypes, DocModel model)
        {
            if (javaMethod.Name != arg.Name)
            {
                if (method.IsConstructor)
                {
                    if (!javaMethod.DeclaringClass.ClassName.EndsWith("/" + arg.Name))
                        return false;
                }
                else
                {
                    return false;
                }
            }
            var pCount = javaMethod.Parameters.Count;
            if (pCount != arg.Parameters.Count())
                return false;
            if (!matchParamTypes)
            {
                // Param match and name matches, fine for now
                return true;
            }

            // Match on param types
            var pIndex = 0;
            foreach (var docParam in arg.Parameters)
            {
                var p = javaMethod.Parameters[pIndex++];
                var paramType = docParam.ParameterType.Resolve(model);
                if (paramType == null)
                {
                    // Param type cannot be resolved, so no match
                    return false;
                }
            }

            return true;
        }
예제 #8
0
 /// <summary>
 /// Resolve this reference into an XmlClass.
 /// </summary>
 public IDocResolvedTypeRef Resolve(DocModel model)
 {
     return(this);
 }