ModuleDescriptor.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Text;
 
using IKVM.ByteCode;
using IKVM.ByteCode.Decoding;
using IKVM.CoreLib.System;
 
namespace IKVM.CoreLib.Modules
{
 
    internal readonly partial struct ModuleDescriptor : IComparable<ModuleDescriptor>
    {
 
        public static bool operator ==(ModuleDescriptor x, ModuleDescriptor y) => x.Equals(y);
 
        public static bool operator !=(ModuleDescriptor x, ModuleDescriptor y) => x.Equals(y) == false;
 
        public static bool operator <(ModuleDescriptor x, ModuleDescriptor y) => Compare(x, y) < 0;
 
        public static bool operator >(ModuleDescriptor x, ModuleDescriptor y) => Compare(x, y) > 0;
 
        public static bool operator <=(ModuleDescriptor x, ModuleDescriptor y) => Compare(x, y) <= 0;
 
        public static bool operator >=(ModuleDescriptor x, ModuleDescriptor y) => Compare(x, y) >= 0;
 
        public static int Compare(ModuleDescriptor x, ModuleDescriptor y) => x.CompareTo(y);
 
        public static ModuleDescriptor Read(ClassFile clazz)
        {
            if (clazz is null)
                throw new ArgumentNullException(nameof(clazz));
 
            try
            {
                if (clazz.Version < 53)
                    throw new InvalidModuleDescriptorException($"Unsupported class file version '{clazz.Version}'.");
 
                if ((clazz.AccessFlags & AccessFlag.Module) != AccessFlag.Module)
                    throw new InvalidModuleDescriptorException("AccessFlags should be ACC_MODULE.");
 
                var clazzName = clazz.Constants.Get(clazz.This).Name;
                if (clazzName != "module-info")
                    throw new InvalidModuleDescriptorException("Class name should be 'module-info'.");
 
                if (clazz.Super.IsNotNil)
                    throw new InvalidModuleDescriptorException("Bad super class.");
 
                if (clazz.Fields.Count > 0)
                    throw new InvalidModuleDescriptorException("Bad fields.");
 
                if (clazz.Methods.Count > 0)
                    throw new InvalidModuleDescriptorException("Bad methods.");
 
                if (clazz.Interfaces.Count > 0)
                    throw new InvalidModuleDescriptorException("Bad interfaces.");
 
                var builder = ReadModuleAttribute(clazz);
                ReadModulePackagesAttribute(clazz, builder);
                ReadModuleMainClassAttribute(clazz, builder);
 
                var descriptor = builder.Build();
 
                // various checks based on whether we are reading java.base or not
                if (descriptor.Name == "java.base")
                {
                    // building java.base itself: should have no requires
                    if (descriptor.Requires.Count > 0)
                        throw new InvalidModuleDescriptorException("The requires table for java.base must be 0 length.");
                }
                else
                {
                    // modules must explicitely require java.base
                    if (descriptor.Requires.Any(i => i.Name == "java.base") == false)
                        throw new InvalidModuleDescriptorException("The requires table must have an entry for java.base.");
                }
 
                return descriptor;
            }
            catch (ByteCodeException e)
            {
                throw new InvalidModuleDescriptorException("Unable to read module descriptor.", e);
            }
        }
 
        static Builder ReadModuleAttribute(ClassFile clazz)
        {
            var attribute = clazz.Attributes.FirstOrDefault(i => i.IsNotNil && i.Name.IsNotNil && clazz.Constants.Get(i.Name).Value == AttributeName.Module);
            if (attribute.IsNil)
                throw new InvalidModuleDescriptorException($"Attribute '{AttributeName.Module}' not found.");
 
            return ReadModuleAttribute(clazz, (ModuleAttribute)attribute);
        }
 
        static Builder ReadModuleAttribute(ClassFile clazz, in ModuleAttribute attribute)
        {
            var moduleName = clazz.Constants.Get(attribute.Name).Name;
            if (moduleName is not null)
                moduleName = DecodeModuleName(moduleName);
            if (moduleName is null || string.IsNullOrEmpty(moduleName))
                throw new InvalidModuleDescriptorException("Module name not found.");
 
            var modifiers = default(ModuleFlag);
            if ((attribute.Flags & ModuleFlag.Open) != 0)
                modifiers |= ModuleFlag.Open;
            if ((attribute.Flags & ModuleFlag.Synthetic) != 0)
                modifiers |= ModuleFlag.Synthetic;
            if ((attribute.Flags & ModuleFlag.Mandated) != 0)
                modifiers |= ModuleFlag.Mandated;
 
            var builder = CreateModule(moduleName, modifiers);
 
            if (attribute.Version.IsNotNil)
                builder = builder.Version(clazz.Constants.Get(attribute.Version).Value);
 
            ReadModuleRequires(clazz, attribute, builder);
            ReadModuleExports(clazz, attribute, builder);
            ReadModuleOpens(clazz, attribute, builder);
            ReadModuleUses(clazz, attribute, builder);
            ReadModuleProvides(clazz, attribute, builder);
 
            return builder;
        }
 
        static void ReadModulePackagesAttribute(ClassFile clazz, Builder builder)
        {
            var attribute = clazz.Attributes.FirstOrDefault(i => i.IsNotNil && i.Name.IsNotNil && clazz.Constants.Get(i.Name).Value == AttributeName.ModulePackages);
            if (attribute.IsNil)
                return;
 
            ReadModulePackagesAttribute(clazz, (ModulePackagesAttribute)attribute, builder);
        }
 
        static void ReadModulePackagesAttribute(ClassFile clazz, in ModulePackagesAttribute attribute, Builder builder)
        {
            foreach (var package in attribute.Packages)
            {
                var packageName = clazz.Constants.Get(package).Name;
                if (packageName is not null)
                    packageName = packageName.Replace('/', '.');
                if (packageName is null || string.IsNullOrEmpty(packageName))
                    throw new InvalidModuleDescriptorException("Bad package name on module packages.");
 
                builder.Package(packageName);
            }
        }
 
        static void ReadModuleMainClassAttribute(ClassFile clazz, Builder builder)
        {
            var attribute = clazz.Attributes.FirstOrDefault(i => i.IsNotNil && i.Name.IsNotNil && clazz.Constants.Get(i.Name).Value == AttributeName.ModuleMainClass);
            if (attribute.IsNil)
                return;
 
            ReadModuleMainClassAttribute(clazz, (ModuleMainClassAttribute)attribute, builder);
        }
 
        static void ReadModuleMainClassAttribute(ClassFile clazz, in ModuleMainClassAttribute attribute, Builder builder)
        {
            var mainClassName = clazz.Constants.Get(attribute.MainClass).Name;
            if (mainClassName is not null)
                mainClassName = mainClassName.Replace('/', '.');
            if (mainClassName is null || string.IsNullOrEmpty(mainClassName))
                throw new InvalidModuleDescriptorException("Bad main class name on module main class attribute.");
 
            builder.MainClass(mainClassName);
        }
 
        static void ReadModuleRequires(ClassFile clazz, in ModuleAttribute attribute, Builder builder)
        {
            foreach (var requires in attribute.Requires)
            {
                var moduleName = clazz.Constants.Get(requires.Module).Name;
                if (moduleName is not null)
                    moduleName = DecodeModuleName(moduleName);
                if (moduleName is null || string.IsNullOrEmpty(moduleName))
                    throw new InvalidModuleDescriptorException("Bad module name on requires.");
 
                var modifiers = default(ModuleRequiresFlag);
                if ((requires.Flag & ModuleRequiresFlag.Transitive) != 0)
                    modifiers |= ModuleRequiresFlag.Transitive;
                if ((requires.Flag & ModuleRequiresFlag.StaticPhase) != 0)
                    modifiers |= ModuleRequiresFlag.StaticPhase;
                if ((requires.Flag & ModuleRequiresFlag.Synthetic) != 0)
                    modifiers |= ModuleRequiresFlag.Synthetic;
                if ((requires.Flag & ModuleRequiresFlag.Mandated) != 0)
                    modifiers |= ModuleRequiresFlag.Mandated;
 
                if (moduleName == "java.base")
                {
                    if ((modifiers & ModuleRequiresFlag.Synthetic) != 0)
                        throw new InvalidModuleDescriptorException("The requires entry for java.base has ACC_SYNTHETIC set");
 
                    // requires transitive java.base is illegal unless:
                    // - the major version is 53 (JDK 9), or:
                    // - the classfile is a preview classfile, or:
                    // - the module is deemed to be participating in preview
                    //   (i.e. the module is a java.* module)
                    // requires static java.base is illegal unless:
                    // - the major version is 53 (JDK 9), or:
                    if (clazz.Version.Major >= 54)
                    {
                        var hasTransitive = (modifiers & ModuleRequiresFlag.Transitive) != 0;
                        var hasStatic = (modifiers & ModuleRequiresFlag.StaticPhase) != 0;
                        if ((hasTransitive && "java.se" != moduleName) || hasStatic)
                            throw new InvalidModuleDescriptorException($"The requires entry for java.base has {(hasStatic ? "ACC_STATIC_PHASE" : "ACC_TRANSITIVE")} set.");
                    }
                }
 
                if (requires.Version.IsNotNil)
                {
                    var version = clazz.Constants.Get(requires.Version).Value;
                    builder = builder.Requires(modifiers, moduleName, version);
                }
                else
                {
                    builder = builder.Requires(modifiers, moduleName);
                }
            }
        }
 
        static void ReadModuleExports(ClassFile clazz, in ModuleAttribute attribute, Builder builder)
        {
            foreach (var exports in attribute.Exports)
            {
                var packageName = clazz.Constants.Get(exports.Package).Name;
                if (packageName is not null)
                    packageName = packageName.Replace('/', '.');
                if (packageName is null || string.IsNullOrEmpty(packageName))
                    throw new InvalidModuleDescriptorException("Bad package name on module exports.");
 
                var modifiers = default(ModuleExportsFlag);
                if ((exports.Flags & ModuleExportsFlag.Synthetic) != 0)
                    modifiers |= ModuleExportsFlag.Synthetic;
                if ((exports.Flags & ModuleExportsFlag.Mandated) != 0)
                    modifiers |= ModuleExportsFlag.Mandated;
 
                builder = builder.Exports(modifiers, packageName, ToHashSet(clazz, exports.Modules));
            }
        }
 
        static void ReadModuleOpens(ClassFile clazz, in ModuleAttribute attribute, Builder builder)
        {
            if (builder.IsOpen)
                if (attribute.Opens.Count > 0)
                    throw new InvalidModuleDescriptorException("The opens table for an open module must be 0 length.");
 
            foreach (var opens in attribute.Opens)
            {
                var packageName = clazz.Constants.Get(opens.Package).Name;
                if (packageName is not null)
                    packageName = packageName.Replace('/', '.');
                if (packageName is null || string.IsNullOrEmpty(packageName))
                    throw new InvalidModuleDescriptorException("Bad package name on module opens.");
 
                var modifiers = default(ModuleOpensFlag);
                if ((opens.Flags & ModuleOpensFlag.Synthetic) != 0)
                    modifiers |= ModuleOpensFlag.Synthetic;
                if ((opens.Flags & ModuleOpensFlag.Mandated) != 0)
                    modifiers |= ModuleOpensFlag.Mandated;
 
                builder = builder.Opens(opens.Flags, packageName, ToHashSet(clazz, opens.Modules));
            }
        }
 
        static void ReadModuleUses(ClassFile clazz, in ModuleAttribute attribute, Builder builder)
        {
            foreach (var uses in attribute.Uses)
            {
                var className = clazz.Constants.Get(uses).Name;
                if (className is not null)
                    className = className.Replace('/', '.');
                if (className is null || string.IsNullOrEmpty(className))
                    throw new InvalidModuleDescriptorException("Bad class name on module uses.");
 
                builder = builder.Uses(className);
            }
        }
 
        static void ReadModuleProvides(ClassFile clazz, in ModuleAttribute attribute, Builder builder)
        {
            foreach (var provides in attribute.Provides)
            {
                var serviceName = clazz.Constants.Get(provides.Class).Name;
                if (serviceName is not null)
                    serviceName = serviceName.Replace('/', '.');
                if (serviceName is null || string.IsNullOrEmpty(serviceName))
                    throw new InvalidModuleDescriptorException("Bad service name on module provides.");
 
                builder = builder.Provides(serviceName, ToArray(clazz, provides.With));
            }
        }
 
        static string DecodeModuleName(string value)
        {
            if (value.Length == 0)
                throw new InvalidModuleDescriptorException("Module name is zero length.");
 
            int i = 0;
            while (i < value.Length)
            {
                int cp = char.ConvertToUtf32(value, i);
                if (cp == ':' || cp == '@' || cp < 0x20)
                    throw new InvalidModuleDescriptorException($"Module name has illegal character: U+{cp:X4}.");
 
                // blackslash is the escape character
                if (cp == '\\')
                    return DecodeModuleName(i, value);
 
                i += CharCount(cp);
            }
 
            return value;
        }
 
        static string DecodeModuleName(int i, string value)
        {
            var sb = new ValueStringBuilder(value.Length - i);
 
            // copy the code points that have been checked
            int j = 0;
            while (j < i)
            {
                int cp = char.ConvertToUtf32(value, j);
                AppendUtf32(ref sb, cp);
                j += CharCount(cp);
            }
 
            // decode from position i to end
            while (i < value.Length)
            {
                int cp = char.ConvertToUtf32(value, i);
                if (cp == ':' || cp == '@' || cp < 0x20)
                {
                    throw new InvalidModuleDescriptorException($"Module name has illegal character: U+{cp:X4}.");
                }
 
                // blackslash is the escape character
                if (cp == '\\')
                {
                    j = i + CharCount(cp);
                    if (j >= value.Length)
                        throw new InvalidModuleDescriptorException("Module name has illegal escape sequence.");
 
                    int next = char.ConvertToUtf32(value, j);
                    if (next != '\\' && next != ':' && next != '@')
                        throw new InvalidModuleDescriptorException("Module name has illegal escape sequence.");
 
                    AppendUtf32(ref sb, next);
                    i += CharCount(next);
                }
                else
                {
                    AppendUtf32(ref sb, cp);
                }
 
                i += CharCount(cp);
            }
 
            return sb.ToString();
        }
 
        static void AppendUtf32(ref ValueStringBuilder builder, int utf32)
        {
            var c = (Span<char>)stackalloc char[2];
            var l = WriteCodePoint(utf32, c);
            builder.Append(c[..l]);
        }
 
        static int WriteCodePoint(int utf32, Span<char> utf16)
        {
            if (utf32 < 0xD800 || (utf32 > 0xDFFF && utf32 < 0x10000))
            {
                utf16[0] = (char)utf32;
                utf16[1] = (char)0;
                return 1;
            }
 
            utf32 -= 0x010000;
 
            utf16[0] = (char)(((0b11111111110000000000 & utf32) >> 10) + 0xD800);
            utf16[1] = (char)(((0b00000000001111111111 & utf32) >> 00) + 0xDC00);
 
            return 2;
        }
 
        static int CharCount(int utf32)
        {
            return utf32 < 0xD800 || (utf32 > 0xDFFF && utf32 < 0x10000) ? 2 : 1;
        }
 
        static ImmutableHashSet<string> ToHashSet(ClassFile clazz, in ModuleConstantHandleTable modules)
        {
            var hs = ImmutableHashSet.CreateBuilder<string>();
            foreach (var i in modules)
                if (clazz.Constants.Get(i).Name is { } name)
                    hs.Add(DecodeModuleName(name));
 
            return hs.ToImmutable();
        }
 
        static ImmutableArray<string> ToArray(ClassFile clazz, in ClassConstantHandleTable classes)
        {
            var ar = ImmutableArray.CreateBuilder<string>(classes.Count);
            foreach (var i in classes)
                if (clazz.Constants.Get(i).Name is { } name)
                    ar.Add(name.Replace('/', '.'));
 
            return ar.ToImmutable();
        }
 
        readonly string _name;
        readonly ModuleVersion _version;
        readonly bool _automatic;
        readonly ModuleFlag _modifiers;
        readonly ImmutableHashSet<ModuleRequires> _requires;
        readonly ImmutableHashSet<ModuleExports> _exports;
        readonly ImmutableHashSet<ModuleOpens> _opens;
        readonly ImmutableHashSet<string> _uses;
        readonly ImmutableHashSet<ModuleProvides> _provides;
        readonly ImmutableHashSet<string> _packages;
        readonly string? _mainClass;
 
        internal ModuleDescriptor(
            string name,
            ModuleVersion version,
            bool automatic,
            ModuleFlag modifiers,
            ImmutableHashSet<ModuleRequires> requires,
            ImmutableHashSet<ModuleExports> exports,
            ImmutableHashSet<ModuleOpens> opens,
            ImmutableHashSet<string> uses,
            ImmutableHashSet<ModuleProvides> provides,
            ImmutableHashSet<string> packages,
            string? mainClass)
        {
            _name = name;
            _version = version;
            _automatic = automatic;
            _modifiers = modifiers;
            _requires = requires;
            _exports = exports;
            _opens = opens;
            _uses = uses;
            _provides = provides;
            _packages = packages;
            _mainClass = mainClass;
        }
 
        public readonly string Name => _name;
 
        public readonly ModuleVersion Version => _version;
 
        public readonly ModuleFlag Modifiers => _modifiers;
 
        public readonly bool IsOpen => (Modifiers & ModuleFlag.Open) != 0;
 
        public readonly bool IsAutomatic => _automatic;
 
        public readonly ImmutableHashSet<ModuleRequires> Requires => _requires;
 
        public readonly ImmutableHashSet<ModuleExports> Exports => _exports;
 
        public readonly ImmutableHashSet<ModuleOpens> Opens => _opens;
 
        public readonly ImmutableHashSet<string> Uses => _uses;
 
        public readonly ImmutableHashSet<ModuleProvides> Provides => _provides;
 
        public readonly ImmutableHashSet<string> Packages => _packages;
 
        public readonly string? MainClass => _mainClass;
 
        public readonly int CompareTo(ModuleDescriptor other)
        {
            int c = _name.CompareTo(other._name);
            if (c != 0)
                return c;
 
            c = _version.CompareTo(other._version);
            if (c != 0)
                return c;
 
            c = _modifiers.CompareTo(other._modifiers);
            if (c != 0)
                return c;
 
            c = CompareTo(_requires, other._requires);
            if (c != 0)
                return c;
 
            c = CompareTo(_packages, other._packages);
            if (c != 0)
                return c;
 
            c = CompareTo(_exports, other._exports);
            if (c != 0)
                return c;
 
            c = CompareTo(_opens, other._opens);
            if (c != 0)
                return c;
 
            c = CompareTo(_uses, other._uses);
            if (c != 0)
                return c;
 
            c = CompareTo(_provides, other._provides);
            if (c != 0)
                return c;
 
            c = Comparer.Default.Compare(_mainClass, other._mainClass);
            if (c != 0)
                return c;
 
            return 0;
        }
 
        static int CompareTo<T>(ImmutableHashSet<T> s1, ImmutableHashSet<T> s2)
        {
            var a1 = s1.ToArray();
            var a2 = s2.ToArray();
            Array.Sort(a1);
            Array.Sort(a2);
            return LexicographicListComparer<T, IComparer<T>, T[]>.Default.Compare(a1, a2);
        }
 
        public readonly override bool Equals(object? obj)
        {
            return obj is ModuleDescriptor other && Equals(other);
        }
 
        public readonly bool Equals(in ModuleDescriptor other)
        {
            return
                _name.Equals(other._name) &&
                _version.Equals(other._version) &&
                _modifiers.Equals(other._modifiers) &&
                _requires.SetEquals(other._requires) &&
                _exports.SetEquals(other._exports) &&
                _opens.SetEquals(other._opens) &&
                _uses.SetEquals(other._uses) &&
                _provides.SetEquals(other._provides) &&
                _packages.SetEquals(other._packages) &&
                _mainClass == other._mainClass;
        }
 
        public readonly override int GetHashCode()
        {
            var hc = new HashCode();
            hc.Add(_name);
            hc.Add(_version);
            hc.Add(_modifiers);
            hc.AddRange(_requires);
            hc.AddRange(_exports);
            hc.AddRange(_opens);
            hc.AddRange(_uses);
            hc.AddRange(_provides);
            hc.AddRange(_packages);
            hc.Add(_mainClass);
            return hc.ToHashCode();
        }
 
        public override string? ToString()
        {
            return _version.IsValid ? _name + " (@" + _version + ")" : _name;
        }
 
    }
 
}