ImportOptionsBinding.cs

Go to the documentation of this file.

#nullable enable
 
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.CommandLine;
using System.CommandLine.Binding;
using System.CommandLine.Builder;
using System.CommandLine.Parsing;
using System.ComponentModel;
using System.IO;
using System.Linq;
 
using IKVM.CoreLib.Diagnostics;
using IKVM.Tools.Core.CommandLine;
 
namespace IKVM.Tools.Importer
{
 
    class ImportOptionsBinding : BinderBase<ImportOptions>
    {
 
        readonly static char[] LIST_SEPARATOR = [',', ';'];
        readonly static char[] KVP_SEPARATOR = ['='];
 
        readonly ImportArgLevel[] _levels;
        readonly ImportOptions _parent;
 
        public ImportOptionsBinding(ImportArgLevel[] nested, ImportOptions parent)
        {
            _levels = nested ?? throw new ArgumentNullException(nameof(nested));
            _parent = parent;
        }
 
        protected override ImportOptions GetBoundValue(BindingContext context)
        {
            var command = (ImportCommand)context.ParseResult.CommandResult.Command;
 
            var options = _parent?.Clone() ?? new ImportOptions();
 
            if (context.ParseResult.GetValueForArgument(command.InputsArgument) is FileInfo[] _inputs)
                options.Inputs = AppendArray(options.Inputs, _inputs);
 
            if (context.ParseResult.GetValueForOption(command.RecurseOption) is string[] _recurse)
                options.Recurse = AppendArray(options.Recurse, _recurse);
 
            if (context.ParseResult.GetValueForOption(command.AssemblyAttributesOption) is FileInfo[] _assemblyAttributes)
                options.AssemblyAttributes = AppendArray(options.AssemblyAttributes, _assemblyAttributes);
 
            if (GetParsedDictionaryValueForOption<string, FileInfo>(context, command.ResourceOption, null) is IReadOnlyDictionary<string, FileInfo> _resources)
                options.Resources = AppendDictionaries(options.Resources, _resources);
 
            if (GetParsedDictionaryValueForOption<string, FileInfo>(context, command.ExternalResourceOption, null) is IReadOnlyDictionary<string, FileInfo> _externalresources)
                options.ExternalResources = AppendDictionaries(options.ExternalResources, _externalresources);
 
            if (context.ParseResult.GetValueForOption(command.OutputOption) is FileInfo _output)
                options.Output = _output;
 
            if (context.ParseResult.GetValueForOption(command.AssemblyNameOption) is string _assemblyName)
                options.AssemblyName = _assemblyName;
 
            if (GetParsedEnumValueForOption(context, command.TargetOption, ImportTarget.Unspecified) is ImportTarget _target and not ImportTarget.Unspecified)
                options.Target = _target;
 
            if (GetParsedEnumValueForOption(context, command.PlatformOption, ImportPlatform.Unspecified) is ImportPlatform _platform and not ImportPlatform.Unspecified)
                options.Platform = _platform;
 
            if (GetParsedEnumValueForOption(context, command.ApartmentOption, ImportApartment.Unspecified) is ImportApartment _apartment and not ImportApartment.Unspecified)
                options.Apartment = _apartment;
 
            if (context.ParseResult.GetValueForOption(command.NoGlobbingOption) is true)
                options.NoGlobbing = true;
 
            if (GetParsedValueForOption<string[]?>(context, command.EnableAssertionsOption, null) is string[] _ea)
                options.EnableAssertions = _ea;
 
            if (GetParsedValueForOption<string[]?>(context, command.DisableAssertionsOption, null) is string[] _da)
                options.DisableAssertions = _da;
 
            if (GetParsedDictionaryValueForOption<string, string>(context, command.PropertiesOption, "") is IReadOnlyDictionary<string, string> _properties)
                options.Properties = AppendDictionaries(options.Properties, _properties);
 
            if (context.ParseResult.GetValueForOption(command.RemoveAssertionsOption) is true)
                options.RemoveAssertions = true;
 
            if (context.ParseResult.GetValueForOption(command.MainClassOption) is string _main)
                options.Main = _main;
 
            if (context.ParseResult.GetValueForOption(command.ReferenceOption) is string[] _references)
                options.References = AppendArray(options.References, _references);
 
            if (context.ParseResult.GetValueForOption(command.NoJNIOption) is true)
                options.NoJNI = true;
 
            if (context.ParseResult.GetValueForOption(command.ExcludeOption) is FileInfo _exclude)
                options.Exclude = _exclude;
 
            if (GetParsedValueForOption<Version?>(context, command.VersionOption, null) is Version _version)
                options.Version = _version;
 
            if (GetParsedValueForOption<Version?>(context, command.FileVersionOption, null) is Version _fileversion)
                options.FileVersion = _fileversion;
 
            if (context.ParseResult.GetValueForOption(command.Win32IconOption) is FileInfo _win32icon)
                options.Win32Icon = _win32icon;
 
            if (context.ParseResult.GetValueForOption(command.Win32ManifestOption) is FileInfo _win32manifest)
                options.Win32Manifest = _win32manifest;
 
            if (context.ParseResult.GetValueForOption(command.KeyFileOption) is FileInfo _keyfile)
                options.KeyFile = _keyfile;
 
            if (context.ParseResult.GetValueForOption(command.KeyOption) is string _keyoption)
                options.Key = _keyoption;
 
            if (context.ParseResult.GetValueForOption(command.DelaySignOption) is true)
                options.DelaySign = true;
 
            if (GetParsedEnumValueForOption(context, command.DebugOption, ImportDebug.None) is ImportDebug _debug and not ImportDebug.None)
                options.Debug = _debug;
 
            if (context.ParseResult.GetValueForOption(command.DeterministicOption) is false)
                options.Deterministic = false;
 
            if (context.ParseResult.GetValueForOption(command.OptimizeOption) is true)
                options.Optimize = true;
 
            if (context.ParseResult.GetValueForOption(command.SourcePathOption) is DirectoryInfo _sourcePath)
                options.SourcePath = _sourcePath;
 
            if (context.ParseResult.GetValueForOption(command.RemapOption) is FileInfo _remap)
                options.Remap = _remap;
 
            if (context.ParseResult.GetValueForOption(command.NoStackTraceInfoOption) is true)
                options.NoStackTraceInfo = true;
 
            if (context.ParseResult.GetValueForOption(command.RemoveUnusedPrivateFieldsOption) is true)
                options.RemoveUnusedPrivateFields = true;
 
            if (context.ParseResult.GetValueForOption(command.CompressResourcesOption) is true)
                options.CompressResources = true;
 
            if (context.ParseResult.GetValueForOption(command.StrictFinalFieldSemanticsOption) is true)
                options.StrictFinalFieldSemantics = true;
 
            if (context.ParseResult.GetValueForOption(command.PrivatePackageOption) is string[] _privatepackages)
                options.PrivatePackages = AppendArray(options.PrivatePackages, _privatepackages);
 
            if (context.ParseResult.GetValueForOption(command.PublicPackageOption) is string[] _publicpackages)
                options.PublicPackages = AppendArray(options.PublicPackages, _publicpackages);
 
            if (context.ParseResult.GetValueForOption(command.NoWarnOption) is Diagnostic[] _nowarn)
                options.NoWarn = options.NoWarn != null ? AppendArray(options.NoWarn, _nowarn) : _nowarn;
 
            if (context.ParseResult.GetValueForOption(command.WarnAsErrorOption) is Diagnostic[] _warnaserror)
                options.WarnAsError = options.WarnAsError != null ? AppendArray(options.WarnAsError, _warnaserror) : _warnaserror;
 
            if (command.RuntimeOption != null)
                if (context.ParseResult.GetValueForOption(command.RuntimeOption) is FileInfo _runtime)
                    options.Runtime = _runtime;
 
            if (context.ParseResult.GetValueForOption(command.ClassLoaderOption) is string _classloader)
                options.ClassLoader = _classloader;
 
            if (command.SharedClassLoaderOption != null)
                if (context.ParseResult.GetValueForOption(command.SharedClassLoaderOption) is true)
                    options.SharedClassLoader = true;
 
            if (context.ParseResult.GetValueForOption(command.BaseAddressOption) is string _baseaddress)
                options.BaseAddress = _baseaddress;
 
            if (context.ParseResult.GetValueForOption(command.FileAlignOption) is string _filealign)
                options.FileAlign = _filealign;
 
            if (context.ParseResult.GetValueForOption(command.NoPeerCrossReferenceOption) is true)
                options.NoPeerCrossReference = true;
 
            if (context.ParseResult.GetValueForOption(command.NoStdLibOption) is true)
                options.NoStdLib = true;
 
            if (context.ParseResult.GetValueForOption(command.LibraryOption) is DirectoryInfo[] _libs)
                options.Libraries = AppendArray(options.Libraries, _libs);
 
            if (context.ParseResult.GetValueForOption(command.NoAutoSerializationOption) is true)
                options.NoAutoSerialization = true;
 
            if (context.ParseResult.GetValueForOption(command.HighEntropyVAOption) is true)
                options.HighEntropyVA = true;
 
            if (context.ParseResult.GetValueForOption(command.ProxyOption) is string[] _proxies)
                options.Proxies = _proxies;
 
            if (context.ParseResult.GetValueForOption(command.AllowNonVirtualCallsOption) is true)
                options.AllowNonVirtualCalls = true;
 
            if (context.ParseResult.GetValueForOption(command.StaticOption) is true)
                options.Static = true;
 
            if (context.ParseResult.GetValueForOption(command.NoJarStubsOption) is true)
                options.NoJarStubs = true;
 
            if (context.ParseResult.GetValueForOption(command.WarningLevel4Option) is true)
                options.WarningLevel4Option = true;
 
            if (context.ParseResult.GetValueForOption(command.NoParameterReflectionOption) is true)
                options.NoParameterReflection = true;
 
            if (command.BootstrapOption != null)
                if (context.ParseResult.GetValueForOption(command.BootstrapOption) is true)
                    options.Bootstrap = true;
 
            if (command.LogOption != null)
                if (context.ParseResult.GetValueForOption(command.LogOption) is string _log)
                    options.Log = _log;
 
            // for each nested level, run a command to capture the options, but otherwise does nothing
            foreach (var level in _levels)
            {
                var nestedCommand = new ImportCommand(false);
                var nestedOptions = new List<ImportOptions>(level.Args.Count);
                nestedCommand.SetHandler(nestedOptions.Add, new ImportOptionsBinding(level.Nested.ToArray(), options));
                new CommandLineBuilder(nestedCommand).Build().Invoke(level.Args.ToArray());
                options.Nested = nestedOptions.ToArray();
            }
 
            return options;
        }
 
        T[] AppendArray<T>(T[] a, T[] b)
        {
            var tmp = new T[a.Length + b.Length];
            a.CopyTo(tmp, 0);
            b.CopyTo(tmp, a.Length);
            return tmp;
        }
 
        IReadOnlyDictionary<TKey, TValue> AppendDictionaries<TKey, TValue>(IReadOnlyDictionary<TKey, TValue> first, IReadOnlyDictionary<TKey, TValue> second)
            where TKey : notnull
        {
            var d = new Dictionary<TKey, TValue>();
 
            foreach (var kvp in first)
                d.Add(kvp.Key, kvp.Value);
 
            foreach (var kvp in second)
                d[kvp.Key] = kvp.Value;
 
            return d;
        }
 
        T GetParsedValueForOption<T>(BindingContext context, Option<string?> option, T defaultValue)
        {
            return context.ParseResult.GetValueForOption(option) is string v ? ParseStringValue<T>(v) ?? defaultValue : defaultValue;
        }
 
        string[]? ParseStringToStringArrayForOption(BindingContext context, Option<string?> option, char[] separator, string[]? defaultValue)
        {
            return context.ParseResult.GetValueForOption(option) is string v ? v.Split(separator, StringSplitOptions.RemoveEmptyEntries) : defaultValue;
        }
 
        int[]? ParseDiagnosticIdListForOption(BindingContext context, Option<string?> option, char[] separator, int[]? defaultValue)
        {
            if (context.ParseResult.GetValueForOption(option) is string v)
                return (int[]?)v.Split(separator, StringSplitOptions.RemoveEmptyEntries).Select(SafeParseDiagnosticId).Where(i => i != null).OfType<int>().ToArray();
            else
                return defaultValue;
        }
 
        int? SafeParseDiagnosticId(string value)
        {
            if (int.TryParse(value, out var i))
                return i;
 
            if (value.StartsWith("IKVM", StringComparison.OrdinalIgnoreCase))
                return SafeParseDiagnosticId(value["IKVM".Length..]);
 
            return null;
        }
 
        T GetParsedEnumValueForOption<T>(BindingContext context, Option<string?> option, T defaultValue)
            where T : notnull, Enum
        {
            return context.ParseResult.GetValueForOption(option) is string v ? (T)Enum.Parse(typeof(T), v, true) : defaultValue;
        }
 
        IReadOnlyDictionary<TKey, TValue> GetParsedDictionaryValueForOption<TKey, TValue>(BindingContext context, Option<string[]> option, TValue? defaultValue)
            where TKey : notnull
        {
            return context.ParseResult.GetValueForOption(option) is string[] v ? ParseDictionaryValues<TKey, TValue>(context, option, v, defaultValue) : ImmutableDictionary<TKey, TValue>.Empty;
        }
 
        IReadOnlyDictionary<TKey, TValue> ParseDictionaryValues<TKey, TValue>(BindingContext context, Option option, string[] values, TValue? defaultValue)
            where TKey : notnull
        {
            var dict = new Dictionary<TKey, TValue>();
 
            foreach (var kvp in values.Select(i => ParseDictionaryValue<TKey, TValue>(context, i)))
            {
                if (dict.ContainsKey(kvp.Key))
                    throw new ToolErrorException($"Option name '{option.Name}' contains multiple values for key '{kvp.Key}'.");
 
                dict[kvp.Key] = kvp.Value ?? defaultValue ?? throw new InvalidOperationException();
            }
 
            return dict;
        }
 
        KeyValuePair<TKey, TValue?> ParseDictionaryValue<TKey, TValue>(BindingContext context, string opt)
            where TKey : notnull
        {
            var c = opt.Split(KVP_SEPARATOR, 2, StringSplitOptions.None);
 
            // parse key value
            var k = ParseStringValue<TKey>(c[0].Trim());
            if (k == null)
                throw new InvalidOperationException();
 
            if (c.Length == 2)
                return new KeyValuePair<TKey, TValue?>(k, ParseStringValue<TValue>(c[1]));
 
            if (c.Length == 1)
                return new KeyValuePair<TKey, TValue?>(k, default);
 
            throw new InvalidOperationException();
        }
 
        T? ParseStringValue<T>(string source)
        {
            if (source is T t)
                return t;
 
            if (typeof(T) == typeof(FileInfo))
                return string.IsNullOrWhiteSpace(source) == false ? (T)(object)new FileInfo(source) : default;
 
            if (typeof(T) == typeof(DirectoryInfo))
                return string.IsNullOrWhiteSpace(source) == false ? (T)(object)new DirectoryInfo(source) : default;
 
            if (typeof(T) == typeof(Version))
                return (T)(object)Version.Parse(source);
 
            if (typeof(T) == typeof(string[]))
                return (T)(object)source.Split(LIST_SEPARATOR, StringSplitOptions.RemoveEmptyEntries);
 
            // fall back to type converter
            if (TypeDescriptor.GetConverter(typeof(T)) is TypeConverter c && c.CanConvertFrom(typeof(string)))
                return (T?)c.ConvertFromString(source);
 
            throw new InvalidOperationException();
        }
 
    }
 
}