示例#1
0
 /// <summary>
 /// Create a type defrinition for the given class file and all inner classes.
 /// </summary>
 public override void CreateType(NetTypeDefinition declaringType, NetModule module, TargetFramework target)
 {
     // Create basic type
     typeDef = new NetTypeDefinition(ClassFile.Empty, target, Scope) { Name = name, Namespace = @namespace, Attributes = Attributes };
     module.Types.Add(typeDef);
     target.TypeNameMap.Add("custom/" + name, typeDef);
 }
示例#2
0
        /// <summary>
        /// Create a type defrinition for the given class file and all inner classes.
        /// </summary>
        public override void CreateType(NetTypeDefinition declaringType, NetModule module, TargetFramework target)
        {
            if (declaringType == null)
                throw new ArgumentNullException("declaringType");
            docClass = target.GetXmlClass(cf);

            var name = NameConverter.UpperCamelCase(inner.IsAnonymous ? cf.Name : inner.Name);
            name = CreateTypeName(declaringType, cf, name, null);

            var finalFullName = parentFullName + "/" + name;

            var attributes = GetAttributes(cf);
            typeDef = new NetTypeDefinition(cf, target, module.Scope) { Name = name, Attributes = attributes };
            typeDef.OriginalJavaClassName = cf.ClassName;
            typeDef.Description = (docClass != null) ? docClass.Description : null;
            parent.AddNestedType(typeDef, "", module, ref finalFullName);

            // Prepare generics
            CreateGenericParameters(cf, typeDef);

            // Add mapping
            RegisterType(target, cf, typeDef);
            CreateNestedTypes(cf, typeDef, finalFullName, module, target);
        }
示例#3
0
 /// <summary>
 /// Adds the given nested type to my type declaration.
 /// </summary>
 protected internal override void AddNestedType(NetTypeDefinition nestedType, string namePrefix, NetModule module, ref string fullNestedTypeName)
 {
     if (TypeDefinition.IsInterface)
     {
         // Add to namespace instead (alter name to avoid duplicates)
         nestedType.Name = typeDef.Name + "_" + namePrefix + nestedType.Name;
         nestedType.Namespace = typeDef.Namespace;
         nestedType.DeclaringType = null;
         fullNestedTypeName = nestedType.FullName;
         module.Types.Add(nestedType);
     }
     else
     {
         TypeDefinition.NestedTypes.Add(nestedType);
     }
 }
示例#4
0
        /// <summary>
        /// Create a type definition for the given class file and all inner classes.
        /// </summary>
        public override void CreateType(NetTypeDefinition declaringType, NetModule module, TargetFramework target)
        {
            if (declaringType != null)
                throw new ArgumentException("Declaring type should be null");
            docClass = target.GetXmlClass(cf);

            var fullName = GetFullName();
            var dotIndex = fullName.LastIndexOf('.');
            var ns = (dotIndex > 0) ? ConvertNamespace(fullName, dotIndex) : String.Empty;
            var name = (dotIndex > 0) ? NameConverter.UpperCamelCase(fullName.Substring(dotIndex + 1)) : fullName;

            name = CreateTypeName(null, cf, name, ns);

            typeDef = new NetTypeDefinition(cf, target, module.Scope);
            typeDef.Name = name;
            typeDef.Namespace = ns;
            typeDef.OriginalJavaClassName = cf.ClassName;
            typeDef.Attributes = GetAttributes(cf, cf.Fields.Any());
            typeDef.IgnoreGenericArguments = !AddGenericParameters;
            typeDef.Description = (docClass != null) ? docClass.Description : null;
            module.Types.Add(typeDef);

            // Prepare generics
            CreateGenericParameters(cf, typeDef);

            // Add mapping
            var finalFullName = string.IsNullOrEmpty(ns) ? name : ns + "." + name;
            RegisterType(target, cf, typeDef);
            CreateNestedTypes(cf, typeDef, finalFullName, module, target);
        }
 protected override void CreateNestedTypes(ClassFile cf, Model.NetTypeDefinition declaringType, string parentFullName, Model.NetModule module, TargetFramework target)
 {
     // Do nothing
 }
示例#6
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"));
        }
示例#7
0
 /// <summary>
 /// Adds the given nested type to my type declaration.
 /// </summary>
 protected internal override void AddNestedType(NetTypeDefinition nestedType, string namePrefix, NetModule module, ref string fullNestedTypeName)
 {
     TypeDefinition.NestedTypes.Add(nestedType);
 }
示例#8
0
 /// <summary>
 /// Adds the given nested type to my type declaration.
 /// </summary>
 protected internal override void AddNestedType(NetTypeDefinition nestedType, string namePrefix, NetModule module, ref string fullNestedTypeName)
 {
     if (typeDef.IsInterface)
     {
         // Add to my parent
         parent.AddNestedType(nestedType, cf.Name + "_" + namePrefix, module, ref fullNestedTypeName);
     }
     else
     {
         typeDef.NestedTypes.Add(nestedType);
     }
 }
示例#9
0
        /// <summary>
        /// Create wrapper for given jar file
        /// </summary>
        private void CreateAssembly(JarFile jf, string folder)
        {
            // Create java type wrappers
            var module = new NetModule(jf.Scope);

            var classTypeBuilders = jf.ClassNames.SelectMany(n => StandardTypeBuilder.Create(jf.LoadClass(n), target));

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

            // Implement and finalize types
            Implement(typeBuilders, target);

            var assemblyAttributes = new List<NetCustomAttribute>();
            if (!importAsStubs)
            {
                // Import code
                var attrType = new NetTypeDefinition(ClassFile.Empty, target, AttributeConstants.Dot42Scope)
                {
                    Name = AttributeConstants.JavaCodeAttributeName,
                    Namespace = AttributeConstants.Dot42AttributeNamespace
                };
                var hash = JarReferenceHash.ComputeJarReferenceHash(jarFilePath);
                var attr = new NetCustomAttribute(attrType, hash);
                assemblyAttributes.Add(attr);
            }

            // Save
            CodeGenerator.Generate(folder, module.Types, assemblyAttributes, target, this, target);
        }